Compare commits

..
11 Commits
174 changed files with 11146 additions and 458 deletions
+27 -1
View File
@@ -1,3 +1,4 @@
import buildlogic.TestHeapPolicy
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins {
@@ -108,8 +109,33 @@ tasks.withType<KotlinCompile> {
tasks.withType<Test>().configureEach {
useJUnitPlatform()
maxHeapSize = "4g"
maxParallelForks = 1
forkEvery = 50
systemProperty("spring.test.context.cache.maxSize", 4)
jvmArgs("-Dfile.encoding=UTF-8")
val gcLogDirectory = layout.buildDirectory.dir("test-gc/$name").get().asFile
doFirst {
val availableBytes = TestHeapPolicy.readAvailableBytes()
val maxWorkers = gradle.startParameter.maxWorkerCount
val heapMiB = TestHeapPolicy.calculateHeapMiB(availableBytes, maxParallelForks, maxWorkers)
maxHeapSize = "${heapMiB}m"
logger.lifecycle(
"Test heap: available estimate={} MiB, workers={}, maxHeap={} MiB (50% worker budget, 25% native reserve)",
availableBytes / (1024 * 1024),
minOf(maxParallelForks, maxWorkers),
heapMiB
)
gcLogDirectory.mkdirs()
}
jvmArgs(
"-Xlog:gc*:file=${gcLogDirectory.resolve("gc-%p.log")}:time,uptime,pid,level,tags:filecount=3,filesize=10M"
)
beforeSuite(
closureOf<TestDescriptor> {
if (className != null) logger.lifecycle("Test class: $className")
}
)
}
tasks.getByName<Jar>("jar") {
+21
View File
@@ -0,0 +1,21 @@
plugins {
`kotlin-dsl`
id("org.jlleitschuh.gradle.ktlint") version "11.5.0"
}
repositories {
mavenCentral()
}
java {
toolchain.languageVersion.set(JavaLanguageVersion.of(17))
}
dependencies {
testImplementation("org.junit.jupiter:junit-jupiter-api:5.8.2")
testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.8.2")
}
tasks.test {
useJUnitPlatform()
}
@@ -0,0 +1,114 @@
package buildlogic
import com.sun.management.OperatingSystemMXBean
import java.io.IOException
import java.lang.management.ManagementFactory
import java.nio.charset.StandardCharsets
import java.util.concurrent.TimeUnit
import java.util.regex.Pattern
object TestHeapPolicy {
private const val MIB = 1L shl 20
private const val JVM_MINIMUM_HEAP_MIB = 2L
private val PAGE_SIZE = Pattern.compile(
"Mach Virtual Memory Statistics:\\s*\\(page size of ([0-9]+) bytes\\)"
)
private val PAGE_COUNTER = Pattern.compile("Pages (free|inactive)\\s*:\\s*([0-9]+)\\.?")
@JvmStatic
fun calculateHeapMiB(availableBytes: Long, maxParallelForks: Int, maxWorkers: Int): Long {
require(availableBytes > 0 && maxParallelForks > 0 && maxWorkers > 0) {
"Available bytes, maxParallelForks and maxWorkers must be positive"
}
val effectiveWorkers = minOf(maxParallelForks, maxWorkers)
val perWorkerBytes = availableBytes / 2 / effectiveWorkers
val nativeReserveBytes = (perWorkerBytes + 3) / 4
val heapMiB = (perWorkerBytes - nativeReserveBytes) / MIB
check(heapMiB >= JVM_MINIMUM_HEAP_MIB) {
"Insufficient test memory: availableBytes=$availableBytes, effectiveWorkers=$effectiveWorkers" +
", heapMiB=$heapMiB. JVM requires at least 2 MiB. Close other applications or reduce workers."
}
return heapMiB
}
@JvmStatic
fun readAvailableBytes(): Long {
val availableBytes = if (System.getProperty("os.name").startsWith("Mac")) {
val builder = ProcessBuilder("/usr/bin/vm_stat").redirectErrorStream(true)
builder.environment()["LC_ALL"] = "C"
try {
val process = builder.start()
try {
process.inputStream.use { output ->
process.errorStream.use {
process.outputStream.use {
check(process.waitFor(5, TimeUnit.SECONDS)) {
"vm_stat did not finish within 5 seconds"
}
check(process.exitValue() == 0) {
"vm_stat failed with exit code ${process.exitValue()}"
}
parseMacVmStat(String(output.readAllBytes(), StandardCharsets.US_ASCII))
}
}
}
} finally {
process.destroyForcibly()
}
} catch (failure: InterruptedException) {
Thread.currentThread().interrupt()
throw IllegalStateException("Interrupted while reading available memory with vm_stat", failure)
} catch (failure: IOException) {
throw IllegalStateException("Unable to read available memory with vm_stat", failure)
}
} else {
val operatingSystem = checkNotNull(ManagementFactory.getPlatformMXBean(OperatingSystemMXBean::class.java)) {
"OperatingSystemMXBean free-memory observation is unavailable"
}
operatingSystem.freeMemorySize
}
check(availableBytes > 0) {
"Available-memory observation must be positive: availableBytes=$availableBytes"
}
return availableBytes
}
internal fun parseMacVmStat(output: String): Long {
var pageSize = -1L
var freePages = -1L
var inactivePages = -1L
try {
for (rawLine in output.lineSequence()) {
val line = rawLine.trim { Character.isWhitespace(it) }
if (line.startsWith("Mach Virtual Memory Statistics")) {
val header = PAGE_SIZE.matcher(line)
require(pageSize < 0 && header.matches()) {
"Duplicate or malformed vm_stat page-size header: $line"
}
pageSize = header.group(1).toLong()
} else if (line.startsWith("Pages free") || line.startsWith("Pages inactive")) {
val counter = PAGE_COUNTER.matcher(line)
require(counter.matches()) { "Malformed vm_stat page counter: $line" }
val pages = counter.group(2).toLong()
if (counter.group(1) == "free") {
require(freePages < 0) { "Duplicate vm_stat Pages free counter" }
freePages = pages
} else {
require(inactivePages < 0) { "Duplicate vm_stat Pages inactive counter" }
inactivePages = pages
}
}
}
require(pageSize > 0 && freePages >= 0 && inactivePages >= 0) {
"vm_stat requires a positive page size and both free and inactive counters"
}
// Raw free already includes speculative pages; do not subtract or add them separately.
return Math.multiplyExact(Math.addExact(freePages, inactivePages), pageSize)
} catch (failure: NumberFormatException) {
throw IllegalArgumentException("vm_stat page size or counters exceed the supported long range", failure)
} catch (failure: ArithmeticException) {
throw IllegalArgumentException("vm_stat page size or counters exceed the supported long range", failure)
}
}
}
@@ -0,0 +1,187 @@
package buildlogic
import org.junit.jupiter.api.Assertions.assertAll
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.DynamicTest
import org.junit.jupiter.api.DynamicTest.dynamicTest
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.TestFactory
class TestHeapPolicyTest {
@TestFactory
fun shouldCalculateHeapWithinTheAvailableWorkerBudget(): List<DynamicTest> = listOf(
dynamicTest("the reported Jenkins availability runs below the former fixed floor") {
assertEquals(879L, TestHeapPolicy.calculateHeapMiB(2_460_004_352L, 1, 1))
},
dynamicTest("1 GiB reserves native memory proportionally") {
assertEquals(384L, TestHeapPolicy.calculateHeapMiB(GIB, 1, 1))
},
dynamicTest("2 GiB does not lose the whole worker budget to a fixed reserve") {
assertEquals(768L, TestHeapPolicy.calculateHeapMiB(2 * GIB, 1, 1))
},
dynamicTest("8 GiB permits a heap below 4 GiB") {
assertEquals(3072L, TestHeapPolicy.calculateHeapMiB(8 * GIB, 1, 1))
},
dynamicTest("10 GiB scales without a policy floor") {
assertEquals(3840L, TestHeapPolicy.calculateHeapMiB(10 * GIB, 1, 1))
},
dynamicTest("20 GiB is shared between two workers") {
assertEquals(3840L, TestHeapPolicy.calculateHeapMiB(20 * GIB, 2, 2))
},
dynamicTest("13 GiB leaves half and a proportional native reserve") {
assertEquals(4992L, TestHeapPolicy.calculateHeapMiB(13 * GIB, 1, 1))
},
dynamicTest("max workers caps four requested forks") {
assertEquals(6144L, TestHeapPolicy.calculateHeapMiB(32 * GIB, 4, 2))
},
dynamicTest("max forks caps four available workers") {
assertEquals(6144L, TestHeapPolicy.calculateHeapMiB(32 * GIB, 2, 4))
},
dynamicTest("fractional MiB rounds down") {
assertEquals(4992L, TestHeapPolicy.calculateHeapMiB(13 * GIB + 2 * MIB, 1, 1))
},
dynamicTest("an exact proportional increase is retained") {
assertEquals(4995L, TestHeapPolicy.calculateHeapMiB(13 * GIB + 8 * MIB, 1, 1))
},
dynamicTest("one byte below the proportional increase rounds down") {
assertEquals(4994L, TestHeapPolicy.calculateHeapMiB(13 * GIB + 8 * MIB - 1, 1, 1))
},
dynamicTest("the JVM technical minimum is not replaced with an application floor") {
assertEquals(2L, TestHeapPolicy.calculateHeapMiB(5_592_406, 1, 1))
},
dynamicTest("the JVM technical minimum accounts for two workers") {
assertEquals(2L, TestHeapPolicy.calculateHeapMiB(11_184_812, 2, 2))
},
dynamicTest("the largest positive long does not overflow") {
assertEquals(3_298_534_883_327L, TestHeapPolicy.calculateHeapMiB(Long.MAX_VALUE, 1, 1))
}
)
@TestFactory
fun shouldRejectOnlyBudgetsTooSmallToStartTheJvm(): List<DynamicTest> = listOf(
Triple(5_592_405L, 1, 1),
Triple(11_184_811L, 4, 2),
Triple(1L, 1, 1),
Triple(MIB, 1, 1),
Triple(2 * MIB, 1, 1),
Triple(4 * MIB, 1, 1)
).map { (available, forks, workers) ->
dynamicTest("[$available, $forks, $workers]") {
val failure = assertThrows(IllegalStateException::class.java) {
TestHeapPolicy.calculateHeapMiB(available, forks, workers)
}
val message = requireNotNull(failure.message)
assertAll(
{ assertTrue(message.contains("availableBytes=$available"), message) },
{ assertTrue(message.contains("effectiveWorkers=${minOf(forks, workers)}"), message) },
{ assertTrue(message.contains("JVM requires at least 2 MiB"), message) },
{ assertTrue(message.contains("Close other applications"), message) },
{ assertTrue(message.contains("reduce workers"), message) }
)
}
}
@TestFactory
fun shouldRejectNonpositiveAvailabilityOrWorkerLimits(): List<DynamicTest> = listOf(
Triple(0L, 1, 1),
Triple(-1L, 1, 1),
Triple(Long.MIN_VALUE, 1, 1),
Triple(10 * GIB, 0, 1),
Triple(10 * GIB, -1, 1),
Triple(10 * GIB, Int.MIN_VALUE, 1),
Triple(10 * GIB, 1, 0),
Triple(10 * GIB, 1, -1),
Triple(10 * GIB, 1, Int.MIN_VALUE)
).map { (available, forks, workers) ->
dynamicTest("[$available, $forks, $workers]") {
assertThrows(IllegalArgumentException::class.java) {
TestHeapPolicy.calculateHeapMiB(available, forks, workers)
}
}
}
@TestFactory
fun shouldParseOnlyRawFreeAndInactivePages(): List<DynamicTest> = listOf(
dynamicTest("4K pages ignore speculative and file-backed counts") {
assertEquals(
2_371_584L,
TestHeapPolicy.parseMacVmStat(
"""
Mach Virtual Memory Statistics: (page size of 4096 bytes)
Pages free: 123.
Pages speculative: 100.
Pages inactive: 456.
File-backed pages: 999.
""".trimIndent()
)
)
},
dynamicTest("16K pages accept reordered counters and whitespace") {
assertEquals(
81_920L,
TestHeapPolicy.parseMacVmStat(
" Mach Virtual Memory Statistics: (page size of 16384 bytes)\n" +
" Pages inactive : 3.\nPages active: 999.\nPages free:\t2.\n"
)
)
},
dynamicTest("both raw counters may be zero") {
assertEquals(0L, TestHeapPolicy.parseMacVmStat(vmStat("4096", "0", "0")))
},
dynamicTest("counters need not have trailing periods") {
assertEquals(20_480L, TestHeapPolicy.parseMacVmStat(vmStat("4096", "2", "3").replace(".\n", "\n")))
},
dynamicTest("the largest representable byte count remains valid") {
assertEquals(Long.MAX_VALUE, TestHeapPolicy.parseMacVmStat(vmStat("1", "9223372036854775806", "1")))
}
)
@TestFactory
fun shouldRejectMissingDuplicateMalformedNegativeOrOverflowingVmStatFields(): List<DynamicTest> {
val valid = vmStat("4096", "2", "3")
return listOf(
"",
"Pages free: 2.\nPages inactive: 3.\n",
"page size of 4096 bytes\nPages free: 2.\nPages inactive: 3.\n",
valid.replace("Pages free: 2.\n", ""),
valid.replace("Pages inactive: 3.\n", ""),
valid + "Pages free: 2.\n",
valid + "Pages inactive: 3.\n",
valid + "Mach Virtual Memory Statistics: (page size of 4096 bytes)\n",
valid + "Pages free: broken.\n",
vmStat("4096", "-1", "3"),
vmStat("4096", "2", "-1"),
vmStat("-4096", "2", "3"),
vmStat("0", "2", "3"),
vmStat("invalid", "2", "3"),
vmStat("4096", "2x", "3"),
vmStat("4096", "2", "3.5"),
valid.replace("Pages free:", "Pages free"),
valid.replace("bytes)", "bytes) trailing"),
vmStat("9223372036854775808", "2", "3"),
vmStat("4096", "9223372036854775808", "3"),
vmStat("1", "9223372036854775807", "1"),
vmStat("4096", "2251799813685248", "0")
).map { output ->
dynamicTest("rejects ${output.replace('\n', ' ')}") {
assertThrows(IllegalArgumentException::class.java) { TestHeapPolicy.parseMacVmStat(output) }
}
}
}
@Test
fun shouldReadPositiveAvailabilityFromTheCurrentOperatingSystem() {
assertTrue(TestHeapPolicy.readAvailableBytes() > 0)
}
private fun vmStat(pageSize: String, free: String, inactive: String): String =
"Mach Virtual Memory Statistics: (page size of $pageSize bytes)\n" +
"Pages free: $free.\nPages inactive: $inactive.\n"
companion object {
private const val MIB = 1_048_576L
private const val GIB = 1_073_741_824L
}
}
@@ -0,0 +1,362 @@
# 관리자 번역 선택 API 계약
> **상태: 서버 구현과 P7 자동 등록 변경의 로컬 검증·부모 직접 검토 완료.** 이 문서의 9개 endpoint와 typed DTO·오류·저장 계약을 구현했다. DEC-11에 따라 controller와 후보 worker는 활성화 설정 없이 애플리케이션 기동 시 등록된다. 기존 외부 최종 APPROVE는 P1~P5 기록이며 P7은 사용자 지시에 따라 부모가 직접 검토·빌드해 종결했다. 운영 MySQL 검증, DDL 실행과 배포는 수행하지 않았다.
배포된 코드에서는 별도 기능 활성화 단계가 없다. 신규 writer가 작업을 생성하기 전에 세 신규 테이블과 source-language 포함 queue unique index를 준비하고, 구 writer와 in-flight 작업 종료 및 구 unique index 제거를 완료해야 한다. 애플리케이션은 DDL을 자동 적용하지 않는다. 후보 worker의 기본 fixed delay 1000ms와 기존 Redisson `lock:translation-selection` 잠금은 유지한다.
## 1. 목적 및 문서 기준
이 문서는 관리자 다중 제공자 번역 후보의 생성·검토·선택·적용을 위한 서버와 프론트엔드 간 계약을 제안한다. 사용자 동작 기준은 [prd.md](prd.md), 구현 순서와 검증 기준은 [plan-task.md](plan-task.md)를 따른다.
이 API는 기존 CONTENT 번역 응답과 `ContentTranslation.renderedPayload` 구조를 변경하지 않는다. 후보 및 승인 출처 정보는 이 제안의 신규 테이블에 저장한다. 신규 경로는 기존 ADMIN 인증 경계 아래 추가하며, 프론트엔드 구현은 범위 밖이다.
## 2. 용어와 상태
| 용어 | 의미 |
|---|---|
| Request | 관리자 1회 생성 요청. 적용은 한 번의 부분 선택으로 종료한다. |
| Scope | 단일 콘텐츠 `CONTENT` 또는 하나의 시리즈 `SERIES`와 요청 생성 시점의 모든 활성 연결 콘텐츠. 시리즈의 비활성 콘텐츠는 제외한다. |
| Candidate | 원본 단위·제공자·대상 언어에 대한 신규 번역 결과 또는 그 제공자별 실패. 기존 번역 메모리와 별도다. |
| Field unit | 콘텐츠 하나의 `title`, `detail`, `tags` 전체 텍스트 후보. |
| Title group | 관리자가 번역 생성 전에 검토한 공통 제목 구간과 구성원. 그룹과 언어별 적용은 원자적이다. |
| Residual | 제목 템플릿에서 공통 구간 및 원문 literal 외의 원문 구간. 구성원 단위로 제공자 후보를 만든다. |
### 2.1 Request 상태
| 상태 | 설명 | 허용 전이 |
|---|---|---|
| `PREPARING` | 대상 스냅샷과 원본 언어를 준비한다. | `REVIEW_REQUIRED`, `READY_TO_GENERATE`, `FAILED`, `CANCELLED` |
| `REVIEW_REQUIRED` | 시리즈 그룹 분석을 관리자 검토에 제공한다. 모든 항목을 개별 처리하는 결과도 검토가 필수다. | `READY_TO_GENERATE`, `CANCELLED` |
| `READY_TO_GENERATE` | 단일 콘텐츠이거나 그룹 검토가 완료됐다. | `GENERATING`, `CANCELLED` |
| `GENERATING` | 확정 manifest의 제공자별 후보 요청을 수행한다. | `READY`, `CANCELLED` |
| `READY` | 각 후보 작업이 성공 또는 실패로 종결됐다. | `APPLIED`, `CANCELLED` |
| `APPLIED` | 선택한 일부 값이 원자 적용됐고 나머지 후보는 폐기됐다. | 종료 |
| `CANCELLED` | 취소가 확정됐다. 진행 중 이미 전송된 외부 호출은 되돌릴 수 없다. | 종료 |
| `FAILED` | 후보 생성 전 준비가 복구 불가능한 오류로 실패했다. | 종료 |
### 2.2 Candidate 상태
`PENDING → RUNNING → SUCCEEDED | FAILED`. 취소 또는 성공적 부분 적용으로 미선택된 작업은 `DISCARDED`로 종료한다. 제공자 실패는 해당 후보의 `FAILED`일 뿐이며 다른 제공자 결과를 대체하지 않는다. 모든 제공자가 실패해도 요청은 후보 작업 종결 후 `READY`가 된다.
## 3. 공통 API 규칙
### 3.1 인증과 응답
- 모든 endpoint는 **`ADMIN` role** 전용이다. `CONTENT_MANAGER`, creator 관리자 role은 이 API의 권한이 아니다.
- 기존 인증 주체 및 null guard를 사용한다. 신규 controller의 권한 규칙은 기존 `@PreAuthorize("hasRole('ADMIN')")` 관례를 따른다.
- 성공과 business error는 기존 `ApiResponse<T>` envelope(`success`, `message`, `data`, `errorProperty`)를 사용한다. Controller는 `ApiResponse.ok(...)`를 반환하고 business 오류는 `SodaException(messageKey, errorProperty)`로 전달한다.
- 오류 envelope의 HTTP 동작은 현재 `SodaExceptionHandler` 계약을 따른다. 이 기능 때문에 공통 exception handler를 바꾸지 않는다. 인증/접근 거부도 기존 Security 및 handler 동작을 유지한다.
- 이 경로의 모든 오류는 `errorProperty`에 아래 안정 코드를 전달하도록 제안한다. 사용자 표시문은 기존 message key/localization 흐름에 둔다. 제공자 raw exception/body는 반환하지 않는다.
### 3.2 타입과 정규화
| 타입 | 표현 및 제약 |
|---|---|
| ID | JSON signed 64-bit integer로 제안. 기존 Kotlin/JPA `Long` 식별자 관례를 유지한다. |
| UUID | 표준 소문자 UUID 문자열. `clientRequestId`, `operationId`에 사용한다. |
| `FieldKey` | `title`, `detail`, `tags` |
| `LanguageCode` | 현재 `TranslationLanguages` 기준 `ko`, `en`, `ja`. source language는 target에서 제외한다. |
| `ProviderId` | 서버가 알려주는 기존 `TranslationProvider.providerId.code`; 고정 후보 목록을 API가 추가로 만들지 않는다. |
| Timestamp | UTC ISO-8601, 초 정밀도. 새 DB timestamp는 MySQL `TIMESTAMP` 소수초 미지정 기준으로 정규화해 DB와 응답에 같은 값을 쓴다. |
| Fingerprint | 정확한 원문·언어 fingerprint를 식별하는 불투명 버전 포함 문자열. 클라이언트가 생성하거나 수정하지 않는다. |
선택 요청은 번역문을 보내지 않는다. 입력 경계에서 scope, ID, target language, group/range, UUID, revision, 선택의 중복 및 상호 일관성을 검증한다. 무제한 전체 결과 반환 대신 cursor page를 쓴다.
### 3.3 공통 오류 코드 제안
| `errorProperty` | 의미 |
|---|---|
| `INVALID_REQUEST` | 필드, 언어, UUID, ID 또는 범위 형식이 올바르지 않음 |
| `RESOURCE_NOT_FOUND` | 요청·콘텐츠·시리즈를 찾을 수 없거나 접근 가능한 scope가 아님 |
| `EMPTY_SCOPE` | 시리즈에 현재 연결된 콘텐츠가 없음 |
| `UNSUPPORTED_SOURCE_LANGUAGE` | 감지/지정된 원본 언어가 지원되지 않음 |
| `LANGUAGE_DETECTION_FAILED` | 원본 언어를 준비할 수 없음 |
| `REVIEW_REQUIRED` | 시리즈 그룹 검토 전에 생성 요청 |
| `INVALID_GROUPING` | 중복·누락 구성원, 유효하지 않은 range 또는 서버 규칙 위반 |
| `REVISION_CONFLICT` | 편집·생성 요청 revision이 최신 값과 다름 |
| `REQUEST_NOT_READY` | 현재 상태에서 수행할 수 없는 요청 |
| `REQUEST_CLOSED` | 취소·적용·준비 실패 상태에 mutation 요청 |
| `CANDIDATE_NOT_SELECTABLE` | 다른 요청·단위·언어·제공자이거나 성공하지 않은 후보 |
| `INCOMPLETE_TITLE_GROUP` | 그룹 공통/구성원 residual 선택이 완전하지 않음 |
| `SOURCE_CHANGED` | 선택 적용 대상 필드의 원본이 생성 snapshot과 달라짐 |
| `MEMBERSHIP_CHANGED` | 선택한 제목 그룹의 현재 시리즈 구성원이 생성 snapshot과 달라짐 |
| `IDEMPOTENCY_CONFLICT` | 동일 idempotency key가 다른 body와 재사용됨 |
오류 코드와 message key는 P3-P5 구현에 추가됐다. P5는 후보 선택 불가·불완전 그룹·원문 변경·구성원 변경의 한국어/영어/일본어 메시지를 연결했다.
## 4. 신규 endpoint 제안
Base path: **`/admin/audio-content/translation-requests`** (P5 종료 시 아래 모든 경로 로컬 구현 완료)
| Method와 경로 | 목적 | 접근 가능 상태 |
|---|---|---|
| `POST /` | 새 scope 요청 및 후보 준비 예약 | 새 요청 생성 |
| `GET /{requestId}` | 상태, 요약, revision 및 적용 영수증 조회 | 모든 상태 |
| `GET /{requestId}/contents` | snapshot 콘텐츠와 현재 값 페이지 조회 | 모든 상태 |
| `GET /{requestId}/grouping` | 제안/검토된 그룹 템플릿 조회 | `REVIEW_REQUIRED` 이후 |
| `PUT /{requestId}/grouping` | 전체 그룹/개별 목록 교체 및 리뷰 확정·수정 | `REVIEW_REQUIRED`, `READY_TO_GENERATE` |
| `POST /{requestId}/generate` | manifest 고정, 생성 작업 시작 | `READY_TO_GENERATE` |
| `GET /{requestId}/candidates` | 단위별 후보/제공자 상태 cursor 조회 | `GENERATING`, `READY`, terminal |
| `POST /{requestId}/apply` | 선택한 subset을 한 트랜잭션에 적용하고 종료 | `READY` |
| `POST /{requestId}/cancel` | 미적용 요청 취소 | 모든 nonterminal 상태 및 `READY` |
`APPLIED` 요청은 취소할 수 없다. 같은 취소의 재시도는 이미 취소됐다는 terminal 응답을 반환한다. 그룹이나 원문 변경 후 재생성을 위한 update/restart endpoint는 제공하지 않는다. 기존 요청을 취소하고 새 요청을 생성한다.
## 5. Request DTO와 응답
### 5.1 요청 생성
`POST /` body:
```json
{
"clientRequestId": "d7c2f4e1-1e4f-4ac2-a6ed-85f2f8102101",
"scope": { "type": "CONTENT", "contentId": 4102 }
}
```
`scope`는 다음 합 타입 중 하나다.
```json
{ "type": "CONTENT", "contentId": 4102 }
{ "type": "SERIES", "seriesId": 981 }
```
Response `data`는 `TranslationSelectionRequestResponse`:
```json
{
"requestId": 710,
"scope": { "type": "SERIES", "seriesId": 981 },
"status": "PREPARING",
"revision": 1,
"createdAt": "2026-11-17T07:00:00Z",
"providerManifest": [],
"targetLanguages": [],
"contentCount": 0,
"progress": { "total": 0, "terminal": 0, "succeeded": 0, "failed": 0 },
"errorCode": null,
"applyReceipt": null
}
```
예시 숫자와 UUID는 schema 설명용 값이며 실제 자원이나 구현된 ID를 지칭하지 않는다. 생성 transaction에서 요청을 `PREPARING`으로 저장하며 현재 활성 series membership의 content ID 집합도 고정한다. 활성 연결 콘텐츠가 없으면 저장된 요청을 `FAILED/EMPTY_SCOPE`로 종결한다. 원본 언어와 필드 snapshot은 비동기 preparation에서 확정한다. 이 시간 구분은 최종 snapshot을 만들기 전에 이미 번역이 시작됐다는 뜻이 아니다.
동일 feature poller가 `PREPARING` request를 lease/fence로 claim한다. 기존 source language를 사용하고 누락된 경우에만 감지한다. 감지 호출 전후 취소를 확인하며 최종 source snapshot 저장 전에 잠금 안에서 원문·언어·활성 membership을 재검증한다. 원문이 달라졌으면 해당 준비를 `FAILED/SOURCE_CHANGED`, membership이 달라졌으면 `FAILED/MEMBERSHIP_CHANGED`로 종결하고 재요청을 안내한다. 준비 중 crash는 lease 만료 후 한 번만 복구하며 두 번째 만료는 `FAILED/PREPARATION_INTERRUPTED`로 종결한다.
Idempotency: `(authenticatedAdminId, clientRequestId)` unique. 동일 UUID와 canonical body hash면 원래 요청을 반환한다. 다른 body hash면 `IDEMPOTENCY_CONFLICT`. 클라이언트는 retry에 같은 UUID와 같은 body를 보낸다.
### 5.2 Request 요약 조회
`GET /{requestId}`는 위 response를 반환한다. `PREPARING`와 `GENERATING` progress는 상태 조회 시점의 단순 snapshot이다. `READY`는 모든 candidate 작업이 terminal인 뜻이며, 일부/전부 실패도 포함한다. `APPLIED`는 receipt를 포함한다. 원시 provider 예외나 credential/요청 body는 포함하지 않는다.
### 5.3 콘텐츠 페이지
`GET /{requestId}/contents?afterContentId={id}&size=50` (`size` 기본 50, 최대 100)
Response data는 `{items: List<ContentSnapshotResponse>, nextAfterContentId: Long?}`다.
| `ContentSnapshotResponse` 필드 | 타입·의미 |
|---|---|
| `contentId`, `active`, `eligible` | `Long`, 조회 시 현재 활성 여부 `Boolean`, 해당 scope의 현재 적용 자격 `Boolean` |
| `sourceLanguage` | 고정 snapshot의 `LanguageCode` |
| `sourceFields` | `Map<FieldKey, String>`; title/detail/tags가 모두 존재 |
| `sourceFingerprints`, `currentSourceFingerprints` | 고정 `Map<FieldKey, String>`과 현재 `Map<FieldKey, String>?` |
| `emptyFields` | `List<FieldKey>`; 번역할 텍스트가 없어 후보를 만들지 않은 필드 |
| `currentTranslations` | `List<{targetLanguage: LanguageCode, fields: Map<FieldKey, String>, approvalOrigins: Map<FieldKey, ADMIN/UNKNOWN>, approvalProvenance: Map<FieldKey, ApprovalProvenance>}>` |
시리즈 scope는 생성 시 활성 member만 포함한다. `sourceLanguage`, `sourceFields`, `sourceFingerprints`는 준비 완료 시 고정된 snapshot이다. `currentTranslations`, `active`는 조회 시점 값이다. 각 item은 `currentSourceFingerprints: Map<FieldKey, String>?`, `eligible: Boolean`도 반환한다. 삭제된 콘텐츠는 현재 fingerprint가 null이고 eligible=false이며 snapshot은 남는다. 프론트엔드는 변경 여부를 표시할 수 있지만 최종 적용 가능 여부는 서버가 잠금 안에서 판정한다.
`approvalOrigins` 값은 `ADMIN` 또는 `UNKNOWN`이다. 유효한 field override row가 있는 값만 `ADMIN`으로 표시한다. 해당 승인 필드에는 `approvalProvenance: Map<FieldKey, {requestId: Long, candidateIds: List<Long>, providers: List<{id: String, version: String}>, approvedBy: Long, approvedAt: Timestamp}>`도 반환한다. 기존 값의 provider는 추정하지 않는다. 현재 translation row가 없으면 현재 원문 fallback을 제공한다. 마지막 페이지의 `nextAfterContentId`는 null이다. `PREPARING`에서는 아직 확정되지 않은 items를 반환하지 않는다.
### 5.4 Grouping 읽기 및 저장
`GET /{requestId}/grouping`의 `data`는 아래 타입이다. `groups`와 `templates`는 저장된 현재 분석/검토 결과이며, generation 이후에는 동결된 동일 값을 반환한다. 그룹 검토 전후 모두 source text를 재구성할 수 있어야 한다.
| 타입 | 필수 필드 |
|---|---|
| `GroupingResponse` | `requestId: Long`, `revision: Long`, `reviewed: Boolean`, `indexUnit: "UNICODE_CODE_POINT"`, `groups: List<TitleGroup>`, `individualContentIds: List<Long>`, `templates: List<TitleTemplate>` |
| `TitleGroup` | `groupId: String`, `sourceLanguage: LanguageCode`, `memberContentIds: List<Long>`, `sharedParts: List<SharedPart>` |
| `SharedPart` | `partId: String`, `sourceText: String`, `occurrences: List<{contentId: Long, startCodePoint: Int, endCodePoint: Int}>` |
| `TitleTemplate` | `contentId: Long`, `groupId: String`, `sourceFingerprint: String`, `segments: List<TitleSegment>` |
| `TitleSegment` | `segmentId: String`, `kind: LITERAL/SHARED/RESIDUAL`, `startCodePoint: Int`, `endCodePoint: Int`, `sourceText: String`, `partId: String?`, `valueIndex: Int?` |
`segments`는 원문 순서다. SHARED의 `partId`와 `valueIndex`는 해당 그룹 `sharedParts` 배열 항목을 가리킨다. RESIDUAL의 `partId`는 null이고 `valueIndex`는 해당 콘텐츠 residual 입력 배열의 0-based 순번이다. LITERAL은 두 값이 null이며 `sourceText`를 그대로 출력한다. Grouped member의 residual 입력 순서는 segments에서 RESIDUAL만 추린 순서와 같다. 하나의 provider 후보 `translatedValues[i]`는 해당 입력 배열의 i번째 구간과 대응한다. 이 계약으로 frontend와 apply 서비스가 동일한 전체 제목 preview를 재구성한다.
`PUT /{requestId}/grouping` body:
```json
{
"expectedRevision": 1,
"groups": [{
"groupId": "g-1",
"memberContentIds": [4102, 4103],
"sharedParts": [{
"partId": "p-1",
"occurrences": [
{ "contentId": 4102, "startCodePoint": 0, "endCodePoint": 5 },
{ "contentId": 4103, "startCodePoint": 0, "endCodePoint": 5 }
]
}]
}],
"individualContentIds": [4104]
}
```
이 JSON은 제안 DTO 형태를 보여주는 예시일 뿐 특정 데이터의 결정된 값이 아니다. body는 요청 전체 scope를 빠짐/중복 없이 그룹 또는 individual에 한 번씩 배정해야 한다. 각 group은 2개 이상 멤버로 구성되고 하나의 source language만 포함한다. 각 part는 모든 group member에 같은 nonempty 원문 substring이 존재해야 한다. 서버는 offset 범위 원문으로 공통 텍스트를 유도한다. 원문 문자열 대체 입력은 받지 않는다.
Index는 Unicode code point 기준 0부터 시작하는 inclusive start, exclusive end다. UTF-16 code unit 인덱스가 아니며 Java grapheme boundary를 자르는 범위는 거부한다. Group ID와 part ID는 요청 안에서 중복될 수 없다. 제출 성공 시 grouping을 저장하고 `revision`을 증가시킨다. 첫 확정은 `REVIEW_REQUIRED`에서 `READY_TO_GENERATE`로 전이한다. 생성 전에는 `READY_TO_GENERATE`에서도 같은 endpoint로 재수정할 수 있고 상태는 유지한다. 모든 individual도 관리자가 검토·확정해야 한다. `GENERATING` 전이 이후에는 grouping을 바꿀 수 없다.
Group read model의 segment 타입은 `LITERAL`, `SHARED`, `RESIDUAL`이다. 원문을 순서대로 이어 붙였을 때 원문 제목과 code point 단위로 완전히 일치해야 한다. literal은 번역 대상이 아닌 공백/구두점/숫자 구간을 그대로 보존한다. 단순한 프론트엔드 수정 또는 잘못된 offset은 `INVALID_GROUPING`이다.
공통 구간 사이의 gap에 문자가 있으면 바깥 공백·구두점만 LITERAL로 분리하고 내부 공백·구두점·숫자를 포함한 구문 전체를 하나의 RESIDUAL로 보낸다. 예를 들어 `비 오는 날`은 세 단어가 아닌 하나의 입력이다. 문자가 전혀 없는 gap은 전체를 LITERAL로 보존한다.
## 6. 후보 생성과 조회
### 6.1 후보 생성
`POST /{requestId}/generate` body:
```json
{ "expectedRevision": 2 }
```
응답은 request 요약이다. Request는 모든 콘텐츠의 `title`, `detail`, `tags` 및 해당 source language 외 현재 지원 언어(`ko`, `en`, `ja`) 전체를 대상으로 삼는다. 생성 시 field/language 선택을 받지 않는다. 등록된 모든 `TranslationProvider`가 각 nonempty generation unit을 독립적으로 새로 호출한다. 대상 언어는 provider configuration이나 기존 번역 메모리에서 추정하지 않는다.
request 잠금 안에서 먼저 저장된 accepted generation revision과 요청 revision의 일치 여부를 확인한다. 이미 수락된 동일 요청이면 현재 state/revision이 달라졌어도 기존 결과를 반환하며 후보를 다시 만들지 않는다. 최초 generate에만 `READY_TO_GENERATE`, 현재 revision, 검토 상태를 검사하고 generation manifest와 candidate 작업을 원자 생성해 `GENERATING`으로 전이한다. 이후 grouping 수정은 허용하지 않는다.
### 6.2 Candidate 페이지
`GET /{requestId}/candidates?afterCandidateId={id}&size=50` (`size` 기본 50, 최대 100)
```json
{
"items": [{
"candidateId": 811,
"unit": { "kind": "FIELD", "contentId": 4102, "field": "detail" },
"provider": { "id": "aws", "version": "translate-2017-07-01" },
"targetLanguage": "ko",
"status": "SUCCEEDED",
"translatedValues": ["달빛 아래에서 나눈 약속입니다."],
"failureCode": null
}],
"nextAfterCandidateId": 811
}
```
실패 candidate에는 `translatedValues: null`, 안정화된 `failureCode`를 제공한다. 실패 원문/외부 response/secret은 숨긴다. 동등한 translated values의 다중 provider 결과는 별도 후보 출처들을 유지한 채 응답에서 동등 그룹으로 묶어 보여줄 수 있다. 동일 후보 비교는 정확한 반환 문자열 기준이며, 원본 provenance는 UNKNOWN 허용이다.
Unit 합 타입:
| `kind` | 필드 | 의미 |
|---|---|---|
| `FIELD` | `contentId`, `field` | 단일 title/detail/tags 전체 문자열 후보 |
| `GROUP_COMMON` | `groupId` | 그룹 내 모든 shared title part의 순서 보존 배열 |
| `TITLE_RESIDUAL` | `groupId`, `contentId` | 해당 member의 residual segment 번역 배열 |
각 candidate는 `inputValues: List<String>`도 반환한다. FIELD 입력/결과는 길이 1이며 `translatedValues[0]`가 최종 해당 필드 값이다. GROUP_COMMON은 grouping.sharedParts 순서, TITLE_RESIDUAL은 해당 template의 residual 순서다. 제공자 응답의 개수가 입력과 다르거나 nonempty 입력의 결과가 공백이면 `FAILED/INVALID_PROVIDER_RESULT`이며 선택할 수 없다. 제공자 ID/version이 동결 manifest와 달라졌거나 사라지면 `FAILED/PROVIDER_CHANGED`로 기록하고 다른 provider/version으로 대체하지 않는다. 마지막 페이지의 `nextAfterCandidateId`는 null이다.
빈 원문과 전부 literal residual은 paid call candidate가 없다. 빈 FIELD는 contents의 `emptyFields: List<FieldKey>`로 표시하고 새 승인 대상에서 제외한다. literal-only residual은 template로 조립하고 선택 candidateId는 null이다. 후보 저장은 global translation memory를 읽거나 갱신하는 행위가 아니다. 상세 문서는 준비 실패의 `PREPARATION_INTERRUPTED`, provider 작업 실패의 `PROVIDER_FAILED`, `PROVIDER_CHANGED`, `INVALID_PROVIDER_RESULT`, `EXECUTION_INTERRUPTED`를 안정 failureCode로 사용한다.
## 7. Apply와 cancel 계약
### 7.1 부분 apply
`POST /{requestId}/apply` body:
```json
{
"operationId": "3b3887e6-60c5-42d7-a310-cf0cbd6d0a84",
"expectedRevision": 3,
"selections": [
{ "kind": "FIELD", "contentId": 4102, "field": "detail", "targetLanguage": "ko", "candidateId": 811 },
{
"kind": "TITLE_GROUP",
"groupId": "g-1",
"targetLanguage": "ko",
"commonCandidateId": 901,
"residualChoices": [
{ "contentId": 4102, "candidateId": 902 },
{ "contentId": 4103, "candidateId": null }
]
}
]
}
```
예시는 합 타입 DTO 구성을 보여준다. `selections`는 비어 있으면 안 된다. client가 translated text를 보내는 자유 형식 override는 지원하지 않는다. Server는 모든 ID가 같은 request의 성공 candidate이며 unit/provider/target과 맞는지 확인한다.
`FIELD`는 콘텐츠·필드·언어마다 하나만 선택 가능하다. `TITLE_GROUP`는 그룹+언어 선택 하나를 뜻하며 `commonCandidateId`와 모든 member residual choice를 완전하게 제공한다. residual이 전부 literal이면 그 member의 `candidateId`는 null이어야 한다. 공통 번역은 선택된 한 provider candidate가 모든 group member에 적용되고, member별 residual은 서로 다른 provider가 선택될 수 있다. 단 하나의 그룹 안에서 member를 omit하거나 공통 provider를 나눌 수 없다. 일부 구성원을 따로 적용하려면 생성 전 grouping을 수정한다.
Apply 처리 규칙:
1. request 행을 잠그고 저장된 operationId/body hash를 먼저 검사한다. 동일 요청의 replay면 기존 receipt를 반환한다. 새 apply에만 READY 상태와 현재 revision 검증을 적용한다.
2. 필요한 Series 부모, CONTENT 부모를 ID 오름차순으로 잠근다. 시리즈 그룹 적용은 활성 membership을 안정적으로 확인할 수 있도록 현재 연결 CONTENT 부모도 잠그며, 구성원 추가/제거는 동일 Series 잠금으로 직렬화한다.
3. 잠금 이후 최신 source·활성 membership·override·payload를 다시 읽고 최종 검증한다. 잠금 전 JPA entity나 로딩된 연관 컬렉션을 그대로 신뢰하지 않는다. FIELD는 선택 필드 fingerprint와 content 존재 여부를 검사하며, SERIES scope일 때 현재 연결·활성 자격도 요구한다. 제목 그룹은 모든 member title fingerprint/language와 고정된 활성 membership 전체를 검사한다. 선택되지 않은 다른 필드 변경은 거부 조건이 아니다.
4. 모든 선택 값을 하나의 DB transaction으로 저장한다. 실패가 하나라도 있으면 어떤 값도 적용하지 않고 request는 `READY` 상태에 남는다.
5. 적용 값만 field-scoped override와 기존 CONTENT rendered payload에 쓴다. 미선택 payload 값은 byte-for-byte 보존한다. Locale row가 없으면 미선택 필드는 현재 source fallback으로 초기화한다.
6. Request를 `APPLIED`로 닫고 선택되지 않은 candidate를 `DISCARDED`로 표시한다. 적용 결과 receipt를 저장한다.
같은 `operationId`와 canonical request body hash는 저장된 receipt를 반환한다. 동일 operation ID를 다른 body에 재사용하면 `IDEMPOTENCY_CONFLICT`. 요청이 APPLIED인데 다른 operation ID로 호출하면 `REQUEST_CLOSED`다. Operation ID는 관리자+request 범위에서 유일하다.
Response `ApplyTranslationSelectionResponse`의 필수 필드는 `requestId: Long`, `operationId: UUID`, `status: "APPLIED"`, `appliedAt: Timestamp`, `appliedFields: List<AppliedField>`, `discardedCandidateCount: Int`다. `AppliedField`는 `contentId: Long`, `field: FieldKey`, `targetLanguage: LanguageCode`, `translatedValue: String`, `candidateIds: List<Long>`, `providers: List<{id: String, version: String}>`다. Group title은 공통·residual 출처를 모두 남긴다. Receipt는 override/payload와 같은 transaction에서 저장하며 재전송에도 불변이다.
### 7.2 취소
`POST /{requestId}/cancel` body 없음. `PREPARING`, `REVIEW_REQUIRED`, `READY_TO_GENERATE`, `GENERATING`, `READY`를 취소할 수 있다. APPLIED에서는 `REQUEST_CLOSED`로 거부한다. Cancel은 새 revision이 없는 stale browser에서도 동작해야 한다.
취소의 선형화 지점은 request 행 gate에서 CANCELLED를 commit하는 시점이다. 이후 새 provider chunk dispatch 승인을 금지한다. 취소보다 먼저 승인을 받은 호출은 이미 진행 중인 작업으로 취급하며, 실제 네트워크 전송이 취소 commit 뒤에 일어나더라도 비용이 발생할 수 있다. 취소 응답은 외부 호출 종료를 기다리지 않고 DB 취소 확정 후 반환한다. 늦은 응답은 candidate로 publish하거나 적용할 수 없다. Network I/O 동안 DB transaction을 유지하지 않는다.
Phase4 transport 기술 확인: 설치된 AWS SDK 2.57.11에서 요청별 execution attribute와 `beforeTransmission`으로 SDK retry마다 같은 gate를 적용한다. AWS는 요청별 남은 15초 API-call/attempt timeout을 사용한다. Apache5의 요청별 connect/read 및 공개 요청별 retryStrategy 설정은 지원되지 않으므로 기존 공유 socket/retry 설정을 유지한다. Papago admin 경로만 기존 RestTemplate 방식으로 connect 3초/read 15초를 제한한다. 15초 dispatch budget과 read timeout을 절대적인 전체 wall-clock 중단 정밀도로 해석하지 않는다. 일반 요청에는 admin control을 적용하지 않는다.
## 8. 프론트엔드 상호작용 명세
이 절은 UI 동작 계약만 정의하며 route/page/component/style을 구현하거나 시각 디자인을 지정하지 않는다.
1. 관리자는 콘텐츠 또는 시리즈 ID로 요청을 만든다. `PREPARING`/`GENERATING` 상태는 1초 간격 polling으로 조회한다.
2. 시리즈는 grouping 분석 화면으로 전이하고 관리자가 모든 콘텐츠를 그룹 또는 개별 상태로 분류해 확정하기 전 generate action을 보내지 않는다. 원문 구간은 code point 인덱스로 변환하고 후보 생성 뒤에는 grouping 편집 대신 cancel 후 재요청을 제공한다.
3. 최초 활성 콘텐츠 snapshot의 title/detail/tags, 언어, 현재 값과 활성 자격, fingerprint 기반 변경 가능성을 request/content pages에서 검토한다. source 언어를 target language로 제시하지 않는다.
4. 생성 완료 후 field candidate를 필드·언어별로 비교한다. 제공자 이름·버전·실패 상태를 확인 가능하게 하고 같은 text 후보를 출처 손실 없이 접어 보여줄 수 있다. 기존 translation origin `UNKNOWN`을 실제 provider처럼 표기하지 않는다.
5. grouped title은 group+language로 공통 선택 하나와 member별 residual 선택을 만든다. 불완전 group은 apply할 수 없으며, 그룹 구성원의 결과를 분리하려면 새 request 전에 group을 나눈다.
6. 사용자가 apply할 선택 subset을 review한 후 operation UUID를 생성해 한번 전송한다. 성공 receipt 이후 같은 request에서 새 선택을 추가할 수 없다. server의 SOURCE_CHANGED/MEMBERSHIP_CHANGED 오류면 이전 후보 재적용 대신 새 request를 시작한다.
7. 검토 전·진행 중·READY 상태에서 cancel할 수 있음을 표시한다. 이미 전송된 외부 호출의 비용은 취소로 되돌릴 수 없다는 점과 적용 미확정 값을 유지하는 동작을 설명한다.
Candidate 문자열은 HTML로 해석하지 않고 text로 표시한다. 화면 시각 규칙, 로딩 애니메이션, responsive layout은 본 계약의 범위가 아니다.
## 9. 내부 데이터 및 변경 불변식
세 테이블과 저장 불변식, worker·writer·rollout 설계는 [plan-task.md §설계 제안](plan-task.md#설계-제안)에 정의한다. Entity/store/controller와 로컬 H2 검증은 구현했으며 운영 schema 적용과 rollout은 별도 승인 대상이다.
필수 동작 불변식:
- `ContentTranslation.renderedPayload`의 기존 schema, API response는 변경하지 않는다.
- 새 candidate는 `TranslationCoordinator`의 first-success fallback, translation memory 조회/갱신을 사용하지 않는다. 모든 등록 provider를 직접 독립 호출한다.
- 기존 translated payload는 명시 적용 때까지 유지한다. 관리 승인 값의 provenance는 override row에 보관하며 과거 provider는 UNKNOWN이다.
- 기존 CONTENT materializer는 Content lock 안에서 최신 원본과 override를 재조회한다. 일치하는 approval은 자동 결과보다 우선한다. 다른 리소스 materialization에는 변경을 적용하지 않는다.
- 원본 mutation은 변경된 field의 override만 제거하고 해당 locale field를 source fallback으로 바꾸며 정상 자동 번역을 schedule한다. Source language 변경은 모든 field를 변경된 것으로 취급한다. 원본이 A→B→A로 되돌아와도 삭제한 이전 approval은 살아나지 않는다.
- 제목 그룹 apply는 선택 그룹 전체 fingerprint와 고정 membership을 검증한다. 개별 field apply는 선택한 field fingerprint만 검증한다.
- 취소 gate, lease/fence, candidate publish 검사로 취소 후 새로운 outbound dispatch 승인이나 late publication/apply를 막는다. 취소 전 승인된 provider 요청에 exactly-once 과금을 보장하지 않는다.
## 10. 계약 상태, 추적 및 검증
| 구분 | 상태 |
|---|---|
| PRD 인터뷰 product decisions | 확정 |
| 이 API endpoint/DTO/error contract | 승인, P1-P5 로컬 구현·집중 검증 완료 |
| persistence 및 server architecture | 로컬 구현 완료, 운영 MySQL 검증 대기 |
| Frontend implementation | 미착수, 범위 밖 |
| Backend implementation | P1~P5 및 최종 gate 보정 완료, APPROVE |
| PRD requirement | 계약 범위 |
|---|---|
| TR-01~TR-02 | Scope 및 contents snapshot |
| TR-03~TR-06, TR-14~TR-15 | Grouping review, generation gate 및 group atomic apply |
| TR-07~TR-13 | Provider manifest, candidate 생성·조회, provenance와 언어 |
| TR-16~TR-17 | One-shot apply, omitted discard 및 cancel |
| TR-18~TR-20 | Content override, field invalidation, selected-field freshness |
실행한 focused test·RED/GREEN·회귀 보정과 명령은 `plan-task.md`의 Progress에 기록했다. 부모가 보정된 최종 코드의 실제 HTTP 27개와 bootJar를 실행해 통과했으며 최종 gate는 APPROVE다. 전체 테스트 `./gradlew test`는 사용자가 실행한다. 실제 MySQL·provider 품질·운영 적용은 별도 검증이다.
### 승인 및 실행 기록 — 2026-11-17
사용자가 설계 승인에 이어 구현 시작을 명시적으로 승인했다. 승인 당시 endpoint와 schema 구현은 없었다. 이후 P1-P5 로컬 구현·집중 검증을 완료했으며 현재 증거와 미완료 운영 검증은 [plan-task.md](plan-task.md)의 Progress 실행 ledger에서 관리한다. Production DDL/deploy/git commit은 승인·실행 범위에 포함되지 않는다.
@@ -0,0 +1,266 @@
# 관리자 번역 후보 선택 프론트엔드 구현 지시
별도 프론트엔드 저장소에서 이 기능을 실제로 구현하라. 이 파일, 사용자가 별도로 제공하는 API 계약 파일, 그리고 네가 작업하는 프론트엔드 저장소만 근거로 삼는다. 제공된 API 계약 외의 백엔드 저장소 PRD·계획·검증 기록·소스, 다른 컴퓨터의 절대 경로, 이전 대화나 숨은 세션 지식에 의존하지 않는다. 아래 지시로 프론트엔드 저장소 안에 새로 만드는 문서는 이후 작업의 기준으로 사용한다. API 계약이 없으면 파일 위치만 물어보고 네트워크 계약을 추측하지 않는다. 계약과 아래 제품 요구가 충돌하면 충돌한 항목만 구체적으로 기록하고 해당 작업을 멈춘 뒤 질문한다.
## 1. 목표와 경계
- 관리자 콘텐츠 상세와 시리즈 상세에 각각 진입 버튼을 두고, 하나의 공유 요청 생성·검토·후보 선택 workflow를 구현한다.
- 기존 프론트엔드의 접근성, 라우팅, API client, 캐시, 상태 관리, 디자인 구성요소, 테스트 관례를 재사용한다. 새 의존성 및 무관한 리팩터링은 피한다.
- 일반 관리자 화면에서 동작하는 완성 기능을 만든다. 스텁, 빈 동작, 가짜 성공, 운영용 mock fallback은 허용하지 않는다.
- 서버 API는 ADMIN 전용이며 별도 feature flag 없이 배포된 애플리케이션 기동 시 등록된다. 프론트엔드에 서버 기능 활성화 토글이나 설정 단계를 만들지 않는다. 버튼 표시만으로 해당 환경의 배포·연결 준비를 완료했다고 판단하지 않는다.
- 사용자가 제공하는 API 계약이 endpoint, DTO, envelope, 오류 및 타입의 기준이다. 아래 요약은 사용 흐름과 제품 요구를 자립적으로 전달한다.
- 서버의 9개 endpoint는 구현됐고 기존 backend 최종 검토에서 승인됐다. 이후 사용자 요청으로 활성화 플래그를 제거했다. 이 기록을 이 저장소의 구현이나 검증 결과로 주장하지 않는다.
- 운영 DDL 반영과 배포는 완료되지 않았다. 새 writer의 작업 생성 전 세 신규 테이블, 원문 언어 포함 queue unique index, 구 writer·in-flight 작업 종료 및 구 unique index 제거가 필요하다. 자동 DDL이나 별도 활성화 단계는 없다. 이 운영 전제는 백엔드 운영자가 처리하며 프론트엔드에서 실행하지 않는다. 실제 UI와 프론트엔드 구현도 아직 없다.
## 2. 구현 전 필수 문서와 조사
### 2.1 저장소 파악
코드를 수정하기 전에 프론트엔드 저장소의 AGENTS.md, README, package/build 설정, 테스트 및 개발 명령을 읽는다. 실제 버튼이 놓일 콘텐츠 상세·시리즈 상세, 기존 API client/envelope/auth, 관리자 role 처리, base URL 환경변수, query/cache 패턴, 번역 언어 및 Unicode 유틸리티, 디자인 구성요소, 테스트 명령을 찾는다. 파일 경로와 명령은 실제 확인한 값만 쓴다.
기존 diff를 먼저 확인해 사용자·다른 작업의 변경과 이번 변경을 구분한다. 자신이 만들지 않은 변경을 덮어쓰거나 되돌리지 않는다.
사용자가 제공한 API 계약 파일을 찾아 읽는다. 파일명이 정해져 있다고 가정하지 않는다. 없다면 구현 전 파일 위치를 요청한다. endpoint나 DTO를 상상해 진행하지 않는다.
### 2.2 코드 작성 전 문서 다섯 개
실제 프론트엔드 저장소의 기존 문서 규칙을 우선 확인한다. 아래 산출물을 그 규칙을 따르는 한 곳에 만들거나 기존 것을 재사용한다. 기존 규칙이 다른 경로를 요구하면 실제 경로를 사용하고 다섯 문서의 canonical mapping을 한 번 기록한다. 중복 계획을 만들지 않는다.
1. `docs/20261118_관리자번역언어선택/api-contract.md`
- 제공된 계약을 의미 변경 없이 그대로 복사한다. 이미 존재하면 내용과 provenance를 확인해 재사용한다.
- 사용자 파일을 덮어쓰지 않는다. 원본 경로와 provenance는 `progress.md`에 기록하고 계약 문서 본문에는 추가하지 않는다.
2. `docs/20261118_관리자번역언어선택/prd.md`
- 이 프롬프트의 제품 요구에서 생성한다. 외부 PRD가 필요하다고 가정하지 않는다.
3. `docs/20261118_관리자번역언어선택/plan-task.md`
- 실제 발견한 프론트엔드 파일 경로, 라우트, 명령을 포함하는 작은 단계와 의존성, acceptance criteria, 증거를 쓴다.
- 체크박스와 고유 Goal ID를 사용하고 활성 Goal은 하나만 둔다. 각 작업에 정확한 경로, focused 검증과 기대 결과를 적는다.
- 알 수 없는 값은 placeholder로 채우거나 이미 확인한 것처럼 쓰지 않는다.
4. `docs/20261118_관리자번역언어선택/verification.md`
- 코드 작성 전에 검증 행렬을 만든다. 각 행은 `NOT_RUN`, `BLOCKED`, `PASS`, `FAIL` 중 하나로 표시하며 기대 assertion, 환경, 명령/증거 경로를 적는다.
- 기존 API client와 envelope, 인증, 관리자 역할, base URL 환경변수, schema availability, connectivity, Unicode 범위 도구, query/cache, 디자인 요소, 테스트 명령을 사전 조사한다.
- 사전 connectivity 확인은 안전한 read-only 요청만 사용한다. 유료 provider 요청, 생성·적용·취소 같은 mutation, 배포나 운영 변경을 사전 점검으로 실행하지 않는다. 알려진 테스트 requestId가 없으면 임의 ID나 존재하지 않는 목록 endpoint로 API 준비 완료를 판단하지 않는다.
- 실제 API 연동 준비가 확인되지 않으면 해당 항목은 `BLOCKED`로 둔다. UI와 단위 테스트 작업은 계속한다.
- fixture/mock 테스트와 실제 서버 검증을 별도 행으로 구분한다.
5. `docs/20261118_관리자번역언어선택/progress.md`
- 승인 범위, 확정 결정, 현재 및 다음 Goal, 완료 Goal, 변경 파일, 가정·결정·차단 요소, 스크린샷 경로를 기록한다.
- 실행한 정확한 명령과 결과, 실제 API 대 fixture 구분을 누적한다. 마지막 requestId는 테스트용만 허용하며 secret은 절대 기록하지 않는다.
다섯 문서가 작성되고 최초 계획 및 검증 기준이 기록될 때까지 production code를 수정하지 않는다. 이후 각 milestone마다 계획 체크박스, progress, verification을 갱신한다. 이미 완료한 목표와 근거는 삭제하거나 과거 PASS를 현재 코드의 증거로 재사용하지 않는다.
장기 작업 재개 시 다섯 문서를 모두 읽고 현재 diff와 테스트 산출물을 확인한다. 실제 evidence에 맞는 첫 미완료 Goal부터 이어가며, 이미 확인된 인터뷰나 완료 작업을 반복하지 않는다. 기존 계획과 사용자 지시가 다르면 사용자 지시가 우선이다. 충돌 우선순위는 사용자 지시, API HTTP 계약, 제품 요구, 실행 계획 순서다. 충돌한 작업만 멈춰 기록한다.
## 3. API 사용 요약
Base path는 `/admin/audio-content/translation-requests`다. Endpoint·필드명·타입은 제공된 API 계약을 기준으로 한다. 아래 제품 동작과 실질적인 충돌이 있으면 요구사항을 임의로 바꾸지 말고 해당 항목을 기록해 확인한다.
| Method | Path | 역할 |
|---|---|---|
| POST | `/` | CONTENT 또는 SERIES 요청 생성 |
| GET | `/{requestId}` | 상태, revision, progress, receipt 조회 |
| GET | `/{requestId}/contents` | snapshot 및 현재 데이터 cursor 조회 |
| GET | `/{requestId}/grouping` | 제목 그룹과 template 조회 |
| PUT | `/{requestId}/grouping` | 전체 grouping 검토·교체 |
| POST | `/{requestId}/generate` | 동결 manifest의 후보 생성 시작 |
| GET | `/{requestId}/candidates` | 후보 cursor 조회 |
| POST | `/{requestId}/apply` | 선택 subset을 한 번 적용 |
| POST | `/{requestId}/cancel` | 미적용 요청 취소, body 없음 |
- 모든 호출은 ADMIN 권한을 요구한다. 기존 auth를 쓰고 role이 없으면 버튼을 숨기며 직접 진입도 차단한다. 서버 설정을 변경하지 않는다.
- 성공 및 business failure는 `success`, `message`, `data`, `errorProperty` envelope를 사용한다. HTTP 200만으로 성공 처리하지 말고 `success`도 확인한다.
- ID는 API의 signed 64-bit numeric Long과 저장소 관례를 따른다. 정밀도를 잃는 JS number 처리를 피하되, 계약/기존 repo가 정한 안전한 직렬화 방식을 사용한다. 임의 string 변환 계약을 만들지 않는다.
- 생성 body는 `clientRequestId: UUID`와 scope 합 타입 `{type: CONTENT, contentId}` 또는 `{type: SERIES, seriesId}`다.
- grouping PUT은 `expectedRevision`, 전체 `groups`(groupId, memberContentIds, sharedParts의 partId 및 contentId/startCodePoint/endCodePoint occurrences), 전체 `individualContentIds`를 보낸다.
- generate body는 `{expectedRevision}`이다. 최초 요청 body와 revision을 보존한다.
- apply body는 `operationId: UUID`, `expectedRevision`, selections 배열이다. FIELD 선택은 `kind: "FIELD"`, contentId, `field: "title" | "detail" | "tags"`, targetLanguage, candidateId를 가진다. 그룹 선택은 `kind: "TITLE_GROUP"`, groupId, targetLanguage, commonCandidateId와 모든 member의 `{contentId, candidateId: 후보 ID 또는 null}` residualChoices를 가진다. 이 표기는 타입 요약이며 실제 JSON은 계약에 맞춰 생성한다.
- 콘텐츠 페이지는 `afterContentId`, 후보 페이지는 `afterCandidateId`, 기본 size 50, 최대 100을 사용한다. `nextAfter...`가 null일 때만 끝이다. 한 페이지를 전체로 간주하지 않는다.
- 후보 ID는 고정이고 같은 ID의 상태·결과가 갱신된다. READY 진입 때 이미 읽은 페이지를 다시 받아 ID 기준으로 갱신한다. revision, cursor, 요청 ID를 임의로 섞지 않는다.
## 4. 제품 동작과 상태 흐름
요청 scope는 콘텐츠 하나 또는 생성 시점의 활성 시리즈 구성원 전체다. 비활성 구성원은 제외한다. 필드는 제목, 상세, 태그다. 대상 언어는 `ko`, `en`, `ja`에서 각 콘텐츠의 source language를 제외한다. 요청 본문에서 필드·언어를 골라 서버 작업을 줄이지 않는다.
source language가 이미 있으면 사용하며 프론트에서 재감지·전환하지 않는다. 준비 중에는 기존 번역이 보존된다. 모든 nonblank 필드, 모든 대상 언어, 서버 manifest의 모든 provider에 대해 fresh generation을 수행한다. provider 목록은 동적 manifest를 사용한다. 현재 backend context에 알려진 AWS와 Papago를 하드코딩하거나 둘만 가정하지 않는다. API key를 프론트에 두지 않고 cache flush나 startup blocking을 추가하지 않는다.
요청 상태 전이:
```text
PREPARING -> READY_TO_GENERATE
PREPARING -> REVIEW_REQUIRED (series)
PREPARING -> FAILED | CANCELLED
REVIEW_REQUIRED -> READY_TO_GENERATE | CANCELLED
READY_TO_GENERATE -> GENERATING | CANCELLED
GENERATING -> READY | CANCELLED
READY -> APPLIED | CANCELLED
APPLIED, FAILED, CANCELLED are terminal
```
- 요청 생성 시 intent마다 UUID를 한 번 만든다. 생성 POST의 결과가 불확실하고 requestId도 받지 못했다면 같은 UUID와 원래 body로 재시도한다. requestId가 있으면 기존 요청 상태를 조회할 수 있다. UUID 검색이나 생성 receipt 조회 API를 새로 가정하지 않으며 UUID를 자동 교체하지 않는다.
- `PREPARING`은 요약 조회를 polling한다. 한 요청당 중복 polling은 금지한다. 1초 간격으로 겹치지 않게 실행하고 unmount, request 변경, terminal 상태에서 멈춘다.
- 단건은 `READY_TO_GENERATE`가 되면 명시적인 generate 버튼을 제공한다. 시리즈는 분석 그룹을 조회하고 관리자가 전체 구성을 확인·확정해야 한다. 모두 개별 처리로 분류한 경우도 review PUT이 필수다.
- 시리즈 grouping은 서버 분석을 그대로 검토·수정한다. 전체 활성 scope를 빠짐없이 한 번씩 그룹 또는 individual에 배치한다. 그룹은 최소 2명, 단일 source language이며 모든 멤버가 정확히 같은 원문 substring을 가져야 한다.
- 관리자는 그룹, 공통 구간, span을 조정하고 멤버를 individual로 제외하거나 요청을 취소할 수 있다. 고정 EP 정규식, 자체 regroup 알고리즘, 서버 분석을 대체하는 프론트 분석을 만들지 않는다.
- span은 Unicode code point 기준 0-based start inclusive/end exclusive다. JavaScript UTF-16 offset과 동일하다고 가정하지 않는다. 브라우저 선택 offset은 기존 변환 유틸 또는 지원 target의 `Intl.Segmenter` 등으로 grapheme 경계를 확인하며, emoji ZWJ와 combining mark를 시험한다. 임의의 오프셋을 제출하지 않는다.
- 그룹 편집이 저장되면 최신 revision을 쓴다. `GENERATING` 진입 후 편집은 금지이며, 변경하려면 취소 후 새 요청을 만든다.
- generate 호출이 불확실하면 같은 원래 `expectedRevision`과 body를 재전송한다. accepted replay는 최신 revision으로 새 요청처럼 바꾸지 않는다. 현재 새 mutation만 최신 revision을 쓴다.
- `GENERATING`은 요약과 필요한 후보 페이지를 polling하며 progress를 표시한다. READY 진입 시 이미 읽은 후보 페이지를 갱신하고 나머지는 필요에 따라 cursor로 읽는다. 모든 후보를 매초 전부 내려받지 않는다. 선택할 그룹의 모든 구성원과 필수 후보를 확보하기 전에는 그 그룹 적용을 허용하지 않는다. polling 중 generate를 다시 보내거나 READY 상태를 자동 적용하지 않는다.
- READY는 모두 성공했다는 뜻이 아니다. 모든 후보 실패 또는 빈 결과여도 READY일 수 있다. `emptyFields`는 paid candidate가 없는 명시 상태로 표시한다.
- 생성 이후 grouping 변경은 안 된다. 재검토가 필요하면 cancel 후 새 요청을 시작한다.
## 5. 비교, 미리보기와 적용
- 콘텐츠 snapshot의 제목·상세·태그, source language, 기존 번역, 현재 활성/eligible 여부, source fingerprint 변경 가능성을 보여준다. snapshot 값과 조회 시점 current 값은 구별한다.
- 후보를 필드, 대상 언어, provider 단위로 비교한다. 원문, 현재 값, AWS/Papago 등 manifest에 포함된 provider 후보를 나란히 확인할 수 있게 한다.
- 기존 번역 출처는 실제 provenance가 없으면 `UNKNOWN`으로 표시한다. 기존 값을 provider에 귀속시키지 않는다.
- 동일 문자열 dedup은 같은 unit과 target language 안에서만 허용한다. 모든 provider ID/version provenance와 실제 selectable candidateId를 보존한다. 다른 unit/언어의 문자열은 합치지 않는다.
- 선택 가능한 것은 `SUCCEEDED` 후보뿐이다. pending, running, failed, discarded는 비활성화한다. 값이 같은 provider 결과를 묶어 보여도 선택되는 실제 candidate ID를 분명히 한다.
- `FIELD`는 콘텐츠·필드·언어마다 후보 하나를 고른다. grouped title을 FIELD로 우회해 apply하지 않는다.
- `GROUP_COMMON`은 group+language 단위 공통 후보 하나를 선택하고 모든 멤버 residual 선택을 완전하게 제공한다. 전부 literal인 멤버는 candidateId null을 사용한다. residual은 멤버마다 다른 provider를 선택할 수 있다.
- 그룹의 일부 멤버만 적용하는 선택은 불가하다. 일부만 분리하려면 generation 전 grouping에서 제외한다.
- candidate의 전체 `translatedValues` 배열을 타입에 맞춰 보존한다. 임의 boolean 조합 상태로 여러 unit 타입을 섞지 않는다.
- 그룹 제목 미리보기는 API `templates.segments`의 순서대로 이어 붙인다. LITERAL은 `sourceText`, SHARED는 선택 공통 후보의 `translatedValues[valueIndex]`, RESIDUAL은 해당 멤버 선택의 같은 인덱스를 쓴다.
- 미리보기에서 trim, 공백 삽입, 값 대체, 문자열 전체 replace를 하지 않는다. residual 구문 내부 공백을 유지한다. 모든 segments를 연결한 원문 재구성이 정확한지 확인한다.
- 후보 문자열은 HTML로 해석하지 않고 text로 출력한다. 긴 제목과 큰 body가 잘리지 않게 검토·비교할 수 있어야 한다.
- 자유 형식 번역 텍스트 편집은 만들지 않는다. 원문 그룹과 spans 편집은 제공한다.
- apply 전에 선택한 그룹의 전체 구성원과 미선택 필드·언어를 포함해 정확한 영향 범위를 확인시킨다. 그룹 내부의 일부 구성원만 미선택으로 두는 적용은 허용하지 않는다. 확인 화면에 다음 문구를 그대로 표시한다: `선택한 항목만 적용하고 이 요청을 종료합니다. 선택하지 않은 후보는 폐기되며, 해당 필드의 기존 번역은 유지됩니다.`
- apply는 one-shot이며 비어 있지 않은 selections만 보낸다. `operationId`는 사용자 확정 직전에 UUID로 만든다. 적용 결과가 불확실하면 requestId로 상태·applyReceipt를 조회하거나 원래 operationId·expectedRevision·선택 body 전체를 보존해 재전송한다. polling에서 새 revision을 받았다는 이유로 재시도 body를 바꾸지 않는다. 적용 결과가 불확실한 동안 선택 편집을 잠근다.
- 성공 후 receipt를 표시하고 request를 닫는다. 생략된 값은 기존 값을 유지한다. 서버가 부분 적용을 원자적으로 처리하며, 성공한 경우에만 해당 콘텐츠/시리즈 query cache를 무효화 또는 재조회한다. 낙관적으로 원본을 덮어쓰지 않는다.
- 적용 뒤 source 변경 시 해당 필드 보호 해제는 서버가 처리한다. 이를 프론트에서 미리 처리하지 않는다.
## 6. 취소, 오류와 복구
- 미적용 상태와 READY에서 취소를 제공한다. APPLIED와 FAILED는 취소하지 않는다.
- 취소는 요청 취소 확정이지 이미 전송된 provider 비용의 환불이나 외부 요청 중단을 뜻하지 않는다. UI 닫힘을 서버 취소 성공으로 간주하지 않는다.
- 화면 이탈 시 기존 앱의 unsaved draft 경고 방식을 재사용한다. requestId를 URL에 보존해 기존 요청을 재개할 수 있게 한다. history list API나 서버 draft API를 새로 만들지 않는다.
- 새로고침 뒤 local 미제출 선택은 사라질 수 있음을 알린다. 기존 저장소 draft 방식이 있다면 재사용한다.
- 안정 오류는 개별 문구/복구에 매핑한다.
- `REVISION_CONFLICT`: 최신 request/grouping을 다시 읽고 사용자 편집을 조용히 덮지 않는다.
- `INVALID_GROUPING`, `INCOMPLETE_TITLE_GROUP`: 입력을 유지하고 수정 가능하게 표시한다.
- `SOURCE_CHANGED`, `MEMBERSHIP_CHANGED`: 이전 후보를 재사용하지 말고 새 요청을 안내한다. 기존 요청은 nonterminal이면 필요 시 취소한다.
- `REQUEST_NOT_READY`, `REQUEST_CLOSED`: 상태를 다시 읽는다.
- `CANDIDATE_NOT_SELECTABLE`, `IDEMPOTENCY_CONFLICT`: 잘못된 후보를 자동 대체하지 않고 원인과 재조회 방법을 알린다.
- `EMPTY_SCOPE`, `LANGUAGE_DETECTION_FAILED`, `UNSUPPORTED_SOURCE_LANGUAGE`, `PREPARATION_INTERRUPTED`: 요청 준비 실패를 분명히 표시한다.
- HTTP 404는 원인을 확정할 수 없다. route 미배포, 네트워크·프록시 경로 또는 base URL·요청 경로를 확인하도록 “API를 사용할 수 없음, 배포·연결 경로 확인 필요”로 표시한다. 기능 OFF 상태나 활성화 설정을 원인으로 안내하지 않는다. fake success/fallback을 만들지 않는다.
- 실제 서버가 없는 경우 fixture/mock은 테스트나 명시적 개발 모드에만 격리한다. production fallback으로 쓰거나 live integration PASS라고 주장하지 않는다.
## 7. 검증 계획과 완료 기준
문서 `verification.md`를 코드 전에 만들고 아래 다섯 그룹의 예상 assertion을 실제 도구와 파일 경로에 연결한다. 구현 과정의 각 검증을 실행 즉시 기록한다. 기존 실패는 그대로 보고하며 테스트를 삭제·skip·약화하지 않는다. 기대값만 echo하는 mock 테스트는 근거가 아니다.
1. Lifecycle, idempotency, polling, cancel
- 두 scope 생성, 상태 전이, 겹치지 않는 polling과 terminal/unmount stop, 동일 UUID/body 재시도, generate replay, 취소 경계를 검증한다.
2. Grouping, coverage, Unicode, preview
- scope 완전 분류, 그룹 최소 멤버, source language 동일성, exact shared spans, emoji ZWJ/combining boundary, literal/shared/residual 연결과 내부 공백을 검증한다.
3. Field/group selection, partial apply, provenance
- selectable 상태, 모든 residual 선택, 그룹 원자성, 일부 필드 적용, 미선택 보존 문구, 같은 결과 dedup 후 provenance/candidate ID 보존, UNKNOWN 출처를 검증한다.
4. Errors, races, unknown outcome, HTTP envelope
- revision conflict 후 refresh, source/membership 변경, incomplete grouping, HTTP 200 business failure, 네트워크 불확실 retry, apply 잠금, 404 API unavailable 상태를 검증한다.
5. 기존 UI 회귀, 접근성, 화면 크기
- 상세/시리즈 기존 동작, role guard와 직접 라우트, keyboard/focus, text escaping, 긴 제목 및 큰 body, responsive layout을 검증한다.
실제 저장소에서 확인한 focused test, lint, typecheck, build 명령만 실행한다. 무필터 전체 테스트와 범위 밖 전체 빌드는 프로젝트 규칙이 허용하지 않으면 실행하지 않는다. 테스트 fixture 검증은 `fixture`로 표기한다. 실제 API E2E는 안전하고 승인된 비운영 테스트 환경과 식별 가능한 fixture가 있을 때만 수행한다. 운영 예시 ID를 넣거나 유료/운영 mutation을 하지 않는다. 환경이 없으면 순수 UI와 unit 작업은 진행하고 실제 연동을 `BLOCKED` 또는 미검증으로 남긴다.
UI가 변경되면 실제 구현 화면을 desktop과 mobile에서 열어 확인하고 스크린샷 경로를 기록한다. 빈 화면, 겹침, 잘림, 읽기 어려운 상태를 확인한다. 자동 테스트만으로 수동 화면 evidence를 대신하지 않는다.
완료는 동작 구현, 다섯 문서 갱신, 실제로 실행한 focused 검증 기록, 실제 화면 검토 및 남은 제한 보고를 모두 충족해야 한다. API 미연동을 성공으로 표현하지 않는다. 보고에는 수정 파일, 정확한 명령과 결과, fixture 대 실제 API 구분, 미검증 환경, 남은 blocker와 스크린샷 경로를 포함한다. commit, deploy, 운영 변경은 별도 명시 승인 없이는 하지 않는다.
## 8. 진행 원칙
- 먼저 문서와 조사를 완료한 뒤 계획의 첫 Goal을 시작한다. 반복 인터뷰는 저장소나 계약에서 답을 찾을 수 없는 핵심 결정에만 한정하고, 질문도 그 미지수만 묻는다.
- 완료한 Goal마다 계획, progress, verification을 같은 시점에 갱신한다. 증거가 없는 체크박스나 PASS는 남기지 않는다.
- 정확한 실제 파일, 명령, 결과만 기록한다. backend 역사적 검증을 frontend evidence로 복사하지 않는다.
- 이 프롬프트를 또 다른 구현 프롬프트로 바꾸지 않는다. bootstrap 문서를 만들고 그 계획에 따라 실제 frontend 기능을 구현한다.
## 9. 화면별 acceptance criteria
### 콘텐츠 상세와 시리즈 상세
- 두 상세 화면에는 기존 권한 및 버튼 패턴에 맞는 번역 후보 선택 진입점을 둔다.
- 콘텐츠 진입은 현재 콘텐츠 ID를 CONTENT scope로 전달한다.
- 시리즈 진입은 series ID를 SERIES scope로 전달한다. 개별 활성 멤버를 프론트에서 수집해 요청 대상을 축소하지 않는다.
- 하나의 공유 workflow를 열되, 현재 상세 화면의 context와 돌아갈 위치를 잃지 않는다.
- ADMIN이 아닌 사용자는 기능 버튼을 보지 못하고, URL을 직접 열어도 인증된 기존 접근 거부 흐름을 따른다.
- 요청 진행 중 같은 요청을 여러 번 생성하는 중복 click을 막는다. 생성의 unknown outcome에서는 기존 UUID를 보존한다.
### 준비 및 grouping 검토
- `PREPARING` 화면은 준비 중임을 표시하고 서버 요약을 재조회한다. 비어 있는 snapshot을 완성 데이터처럼 보여주지 않는다.
- `FAILED`에는 API의 failure code를 사람이 이해할 수 있는 상태로 나타내고 재시작은 새 요청을 통해서만 한다.
- 시리즈 `REVIEW_REQUIRED`에서 모든 snapshot 멤버를 식별하고, 그룹/개별 배정이 전체 scope를 덮는지 사용자에게 보여준다.
- 그룹 멤버, 원문 제목, 공통 span, residual과 literal 분할을 검토할 수 있어야 한다.
- 편집은 원문 구간 선택에 한정한다. 번역문을 직접 편집하는 입력창은 두지 않는다.
- span을 제출하기 직전에 code point start/end, nonempty substring, grapheme 경계, 각 멤버의 substring 동등성을 확인한다.
- 저장 중에는 중복 PUT을 막고 저장 결과의 최신 revision을 사용한다. 충돌이면 서버 최신 grouping을 읽되 사용자 변경을 자동 폐기하지 않는다.
- 검토 완료 버튼은 전체 coverage가 유효할 때만 활성화한다. 모든 individual 구성도 서버에 review PUT을 보내야 한다.
- group과 개별 처리의 제외는 서버에 저장된 후에만 확정 표시한다.
### 후보 생성 및 비교
- `READY_TO_GENERATE`에서는 시작 전 scope, 필드, source/target language, 동적 provider manifest를 간단히 요약한다.
- generate 전송 이후 버튼을 잠그고, progress `total`, `terminal`, `succeeded`, `failed`를 서버 응답 기준으로 표시한다.
- `GENERATING`과 READY 간 경합에서도 상태를 최신화한다. 늦게 도착한 이전 polling 응답이 새 상태를 덮지 않도록 request identity를 확인한다.
- cursor pagination은 반복 cursor 및 중복 응답에서도 ID 기준 병합으로 안정적이어야 한다. 페이지 로드 실패를 전체 결과 완료로 표시하지 않는다.
- 후보 실패는 다른 provider의 성공을 숨기거나 대체하지 않는다. provider/version과 실패 상태를 알 수 있는 곳에 둔다.
- 같은 텍스트 결과를 묶었을 때 선택은 정확한 성공 candidate ID 하나에 연결되어야 하며, 출처 표시는 모든 동등 candidate를 포함한다.
- `emptyFields`와 literal-only residual에는 후보 선택을 요구하지 않는다. 빈 후보를 성공 상태로 만들어 apply할 수 있게 하지 않는다.
- 후보 페이지를 다시 읽을 때 현재 선택 candidate가 더 이상 selectable이 아니면 선택을 해제하고 사용자에게 알린다.
### 적용 확인, receipt와 종료
- 선택 누락, 중복, 다른 언어/단위의 후보 ID는 프론트에서 제출하지 않는다. 서버 검증을 대신한다고 가정하지도 않는다.
- grouped title 미리보기는 각 그룹 멤버의 template마다 개별적으로 재구성한다. 공통 결과 하나를 모든 전체 제목으로 대체하지 않는다.
- 적용 요약은 선택된 콘텐츠·필드·언어, 공통 그룹 전체 멤버, residual source, provider provenance를 구분한다.
- 미선택 필드가 유지됨과 선택하지 않은 후보가 폐기됨을 확인 단계에서 함께 알린다.
- 확인 취소는 API 호출을 보내지 않고, 확인 후에는 operation ID 및 canonical body를 고정해 한 번 전송한다.
- 적용 실패 시 서버가 실패를 반환하면 현재 request 상태와 선택을 유지할 수 있는지 계약에 따라 처리한다. 이미 적용된 receipt를 실패로 표시하지 않는다.
- apply 응답의 immutable receipt를 보여주고, 재조회 시에도 같은 결과를 표시한다. receipt의 applied fields와 provider source를 candidate 페이지가 바뀌어도 잃지 않는다.
- 성공 이후 영향받은 content 및 series 화면의 기존 query cache만 갱신한다. 실패나 unknown outcome에서 기존 데이터를 낙관적으로 변경하지 않는다.
- 취소 요청은 서버 응답 전까지 취소 완료로 표시하지 않는다. 취소 전에 전송 승인을 받은 provider 호출은 계속될 수 있고 이미 발생한 비용을 되돌리지 못함을 사용자에게 설명한다.
## 10. 문서와 검증 기록 형식
`plan-task.md`에는 저장소가 지원하는 형식을 따르되 실제 이 구현을 재개할 수 있는 정보를 남긴다.
- 상단에 현재 상태, 현재 활성 Goal, 다음 Goal을 기록한다.
- 각 Phase에는 결과와 선행 의존성을 기록한다.
- 각 Task에는 고유 ID, 목적, 시작 조건, 완료 증거, 범위 밖, 실제 파일 경로, 테스트 우선 절차와 focused 명령을 적는다.
- 테스트 가능한 작업은 실패하는 assertion부터 작성하고 실패를 확인한 후 최소 구현, 통과 확인과 회귀를 기록한다.
- 테스트가 불가능한 작업에는 구체적인 사유와 대체 증거를 적는다.
- 하나의 Task 또는 Gate Goal만 active로 둔다. 성공한 Goal은 즉시 체크하고 그 Goal의 검증 결과를 progress에도 남긴다.
- 전체 사용자 테스트를 실행하지 않았다면 결과처럼 기록하지 않는다. 프로젝트가 지정한 사용자 실행 명령과 범위를 구분해 둔다.
`verification.md`의 초기 표에는 적어도 다음 열을 둔다.
| 검증 대상 | 기대 assertion | 환경·fixture | 실제 명령 또는 수동 절차 | 상태 | 증거 |
|---|---|---|---|---|---|
| 문서 bootstrap | 다섯 문서와 실제 경로가 확인됨 | local repo | 확인 후 입력 | NOT_RUN | 경로 |
| API 준비도 | auth, base URL, route/schema 사전조건을 안전하게 확인 | read-only | 실제 확인 명령 | NOT_RUN 또는 BLOCKED | 결과 |
| lifecycle 및 retry | 상태·UUID·revision 불변 | fixture 또는 승인된 test API 명시 | focused test | NOT_RUN | 결과 파일 |
| grouping 및 Unicode | coverage, span, grapheme, preview 일치 | fixture 명시 | focused test | NOT_RUN | 결과 파일 |
| apply와 provenance | 부분 적용 및 source 보존 | fixture 또는 승인된 test API 명시 | focused test | NOT_RUN | 결과 파일 |
| 오류와 UI 회귀 | envelope, 오류, role, keyboard, layout | fixture/local UI | 실제 명령·화면 확인 | NOT_RUN | 결과 및 screenshot |
| live API 통합 | 실제 서버가 있다면 read-only/승인된 test scope에서 확인 | 환경 이름과 fixture | 정확한 요청 경로 | BLOCKED 또는 NOT_RUN | 결과 |
표의 행을 모두 실제 환경에 맞게 구체화한다. 행 예시는 완료 증거가 아니다. `PASS`는 assertion 또는 수동 관찰 evidence가 있을 때만 쓴다. `FAIL`은 문제와 재현 절차를 남기고 수정 전 기록을 보존한다. `BLOCKED`에는 무엇이 없어서 막혔는지 쓴다.
`progress.md`는 실행 가능한 재개 노트로 작성한다.
- 승인된 범위와 현재 단계, 다음 단계, 활성 Goal을 먼저 보여준다.
- 확정 제품 결정과 API 계약 의존성을 간결하게 적는다.
- 완료 Goal별 실제 수정 파일과 검증 결과를 연결한다.
- 각 명령은 정확한 working directory와 결과/종료 상태를 기록한다.
- fixture 테스트와 live API 검증을 구분하고, 미실행 검증을 표시한다.
- 미해결 blocker, 가정, 사용자 질문과 답, 스크린샷 경로를 누적한다.
- requestId 기록이 필요한 경우 테스트 식별자만 쓰고 토큰, cookie, authorization header, API key, 개인정보를 기록하지 않는다.
## 11. 구현 완료 보고 형식
작업 종료 시 사용자에게 결과를 한국어로 짧게 보고한다. 코드 완료와 문서 완료를 구분하고 아래 정보를 빠뜨리지 않는다.
1. 구현된 동작과 주요 진입 경로.
2. 변경 파일 목록과 다섯 문서의 실제 위치.
3. 실제 실행한 focused test, lint, typecheck, build 명령 및 각 결과.
4. fixture/mock 검증과 실제 API 검증의 구분. 운영이 아닌 실제 서버 확인이 없으면 미검증으로 표시.
5. 화면 확인의 desktop/mobile 범위와 스크린샷 경로.
6. 남은 blocker, 환경 제약, 실제로 실행하지 않은 검증.
미완료 항목을 완료로 포장하지 않는다. 전체 검증이 불가능하더라도 안전하게 분리 가능한 UI와 테스트 구현을 마치고, 미검증 범위를 명시한다. backend 과거 검증 숫자나 리뷰 승인 문구를 frontend 성공 증거로 재사용하지 않는다.
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,152 @@
# 관리자 번역 후보 선택 및 시리즈 제목 그룹화 PRD
## 문서 정보
| 항목 | 내용 |
|---|---|
| 문서 상태 | 서버 구현 및 DEC-11 플래그 제거·로컬 검증·부모 직접 검토 완료, 운영 적용 미실행 |
| 작성일 | 2026-11-17 |
| 최종 수정일 | 2026-11-18 |
| 대상 제품 | 관리자 다중 제공자 번역 후보 선택 및 시리즈 제목 그룹화 |
| 작성자·결정권자 | 제품 결정권자: 사용자 인터뷰 확인 사항 |
| 관련 API Contract | [api-contract.md](api-contract.md), 9개 endpoint 구현 완료 |
| 관련 구현 계획 | [plan-task.md](plan-task.md), P1~P5 완료, P7 자동 등록 변경 및 별도 운영 전제 |
| 관련 review | [설계 검토](reviews/design-review.md), [구현 검토·QA](reviews/implementation-review.md) |
### 요구사항 상태
이 문서는 제품 동작에 대한 인터뷰 확정사항을 기록한다. API 계약과 기술 설계 제안은 사용자가 승인했으며 서버 구현과 focused tests를 시작하도록 명시적으로 승인했다. 승인 범위는 로컬 서버 구현과 focused tests이며 production DDL/deploy/git commit은 포함하지 않는다. 승인된 활성-only series 구성원, one-shot subset apply, 자유 형식 번역문 제외 결정을 유지한다.
## 1. 개요
관리자는 단일 콘텐츠 또는 시리즈의 현재 활성 구성원 전체를 대상으로 번역 후보를 검토하고 선택할 수 있어야 한다. 시리즈에서는 실제 제목을 분석해 반복되는 공통 제목 구간을 묶고, 공통 구간과 개별 제목의 번역을 분리해 관리한다. 선택한 값만 적용하며, 기존 자동 번역과 관리자의 필드별 수정 상태를 보존한다.
## 2. 문제
관련 에피소드 제목의 번역이 서로 일관되지 않을 수 있다. 기존 단일 번역 흐름만으로는 여러 번역 제공자의 결과를 비교하거나 시리즈 제목의 공통 부분을 함께 검토하기 어렵다. 관리자가 결과를 검토하기 전에 자동으로 값을 덮어쓰면 원치 않는 번역 변경이 발생할 수 있다.
## 3. 목표
- 관리자가 번역 제공자별 후보를 비교하고 대상 필드에 적용할 후보를 선택한다.
- 시리즈 구성원 제목에서 공통 구간과 개별 구간을 검토하고, 공통 구간 번역을 그룹 단위로 적용한다.
- 분석·생성 결과를 검토하고 명시적으로 선택하기 전까지 기존 번역 결과를 유지한다.
- 일부 필드만 적용할 수 있고, 미선택 필드는 현재 값을 유지한다.
## 4. 범위 제외
- 자유 형식의 번역문을 직접 입력·편집하는 기능은 현재 요청에 포함되지 않아 설계에서 제외한다. 이는 별도 인터뷰에서 거부된 기능이라는 뜻이 아니다. 원문 그룹과 구간(span)을 조정하는 편집은 포함한다.
- 전역 초기화 기능, 새 번역 제공자 추가, 원작 관련 동작, 용어집 또는 LLM 시스템 도입.
- 프론트엔드 코드 구현과 UI 시각 스타일 규격.
- 실제 운영 환경에서의 번역 정확도 및 처리량 보장. 현재 근거가 확인되지 않았으며 제품 요구 확정을 막는 질문으로 취급하지 않는다.
## 5. 사용자와 권한
| 사용자 | 목표 | 주요 작업 |
|---|---|---|
| 관리자 | 번역 결과의 일관성과 정확성을 통제 | 대상 선택, 분석 검토·수정, 필드별 후보 선택, 취소 및 적용 |
이 기능은 기존 관리자 권한 경계 안에서 제공한다. 인증·인가의 구체적인 계약은 기존 시스템과의 연동 설계에서 확인한다.
## 6. 핵심 흐름
1. 관리자가 단일 콘텐츠 또는 시리즈를 선택한다. 시리즈 대상은 요청 생성 시점의 현재 활성 구성원 전체다.
2. 시스템이 시리즈 제목을 분석해 반복되는 공유 구간과 각 제목의 고유 구간을 제시한다. 고정된 EP 표기 규칙을 전제로 하지 않는다.
3. 관리자는 생성 전에 분석 결과를 검토하고, 원문 그룹과 구간을 조정하거나 특정 콘텐츠를 그룹에서 제외해 개별 처리 대상으로 바꿀 수 있다. 생성 뒤에는 그룹을 수정할 수 없으며, 수정하려면 요청을 취소하고 새 요청을 만든다.
4. 시스템은 제목·상세·태그와 원본 언어를 제외한 지원 언어에 대해 등록된 각 제공자를 독립적으로 새로 호출한다. 이전 결과는 적용 전까지 유지한다.
5. 관리자는 제공자 출처를 확인하고 적용할 후보의 필드와 언어를 선택한다. 같은 후보는 제공자 출처를 모두 보존한 채 묶어 표시할 수 있다. 제공자별 실패도 결과에 표시한다.
6. 관리자는 검토 또는 생성 중 취소하거나 선택한 일부 후보를 한 번에 적용한다. 적용에서 생략한 후보는 폐기되고, 미선택 번역 값은 그대로 둔다.
## 7. 기능 요구사항
### 7.1 대상과 분석
| ID | 상태 | 요구사항 | 수용 기준 |
|---|---|---|---|
| TR-01 | 확정 | 단일 콘텐츠 대상은 해당 콘텐츠의 제목, 상세, 태그 번역 필드를 처리할 수 있어야 한다. | 선택한 단일 콘텐츠의 세 필드를 번역 후보 대상으로 지정할 수 있다. |
| TR-02 | 확정 | 시리즈 대상은 현재 연결된 활성 구성원 전체의 제목, 상세, 태그 번역 필드를 포함해야 한다. 비활성 구성원은 제외한다. | 요청 생성 시 활성 연결 콘텐츠를 빠짐없이 포함하고 비활성 콘텐츠는 후보 생성과 제목 분석에서 제외한다. |
| TR-03 | 확정 | 시리즈 제목 분석은 실제 제목들을 바탕으로 반복되는 공유 구간과 고유 구간을 식별해야 한다. | 임의의 제목 형식에 적용할 수 있으며 고정된 EP 번호 parsing 규칙을 요구하지 않는다. |
| TR-04 | 확정 | 관리자는 번역 후보 생성을 시작하기 전에 그룹 분석 결과를 검토하고 원문 그룹과 구간(span)을 수정할 수 있어야 한다. | 생성 전에 분석을 검토하고 수정한 그룹·구간을 기준으로 다음 단계에 진입할 수 있다. 생성 이후 그룹 수정은 취소 후 새 요청에서만 가능하다. |
| TR-05 | 확정 | 관리자는 후보 생성을 시작하기 전에 콘텐츠를 공통 제목 그룹에서 제외해 개별 처리 대상으로 바꿀 수 있어야 한다. | 제외된 콘텐츠의 제목은 공통 그룹 적용 대상이 되지 않고 개별 후보로 처리된다. 생성 이후 변경은 취소 후 새 요청에서 가능하다. |
| TR-06 | 확정 | 단일 콘텐츠 번역을 먼저 해야 시리즈 번역을 시작할 수 있다는 순서 제약을 두지 않는다. | 시리즈 대상 처리를 단일 콘텐츠 처리 완료 여부에 종속하지 않는다. |
### 7.2 후보 생성과 검토
| ID | 상태 | 요구사항 | 수용 기준 |
|---|---|---|---|
| TR-07 | 확정 | 제목·상세·태그 전체와 원본 언어를 제외한 지원 대상 언어에 대해 등록된 모든 제공자를 각각 새로 호출해야 한다. | 후보 생성은 일부 필드·언어만 선택하도록 요구하지 않는다. 기존 후보를 재사용해 새 요청을 생략하지 않는다. 각 제공자 결과는 출처와 연결된다. |
| TR-08 | 확정 | 새 결과가 생성되는 동안 기존 번역 결과를 유지해야 한다. | 관리자가 새 후보를 선택해 적용하기 전에는 기존 결과가 바뀌지 않는다. |
| TR-09 | 확정 | 후보는 필드별로 제공자를 선택할 수 있어야 한다. | 제목, 상세, 태그 등 각 필드의 선택이 다른 필드 선택에 종속되지 않는다. |
| TR-10 | 확정 | 동일한 후보 텍스트를 제공자 출처를 보존한 채 묶어 표시할 수 있어야 한다. | 묶인 후보의 모든 제공자 출처를 확인할 수 있다. 동일 결과라는 이유로 출처 정보를 버리지 않는다. |
| TR-11 | 확정 | 제공자 실패를 관리자에게 표시해야 한다. | 실패한 제공자와 실패 상태를 확인할 수 있고, 다른 제공자의 후보는 계속 검토할 수 있다. |
| TR-12 | 확정 | 기존 번역의 제공자 출처가 알려져 있지 않을 수 있음을 허용해야 한다. | 출처 불명인 기존 값에 특정 제공자를 추정해 표시하지 않는다. |
| TR-13 | 확정 | 원본 언어가 사용 가능하면 그 값을 사용하고, 정확한 원본 언어를 일상적으로 다시 감지하지 않는다. | 기존 원본 언어 정보를 사용할 수 있는 상황에서 매번 재감지를 요구하지 않는다. |
### 7.3 적용, 취소 및 데이터 보존
| ID | 상태 | 요구사항 | 수용 기준 |
|---|---|---|---|
| TR-14 | 확정 | 공통 제목 후보의 선택과 적용은 그룹 및 언어 단위로 하나의 불가분 작업이어야 한다. | 공통 제목 그룹의 특정 언어에 대해 선택한 공통 후보가 해당 그룹에 함께 적용된다. |
| TR-15 | 확정 | 관리자는 후보 생성 전에 개별 콘텐츠를 공통 그룹에서 제외할 수 있어야 한다. | 제외한 콘텐츠는 공통 후보 적용에서 빠지고 나머지 그룹 구성원은 그룹 단위 적용을 유지한다. 생성 후 그룹 편집은 취소와 새 요청이 필요하다. |
| TR-16 | 확정 | 관리자는 생성된 전체 후보 중 일부만 선택해 한 번 적용할 수 있어야 한다. 적용은 요청을 닫고 나머지 후보를 폐기한다. | 미선택 필드·언어 값은 기존 값을 유지한다. 요청을 닫은 뒤 누락 후보를 같은 요청에서 다시 적용할 수 없다. |
| TR-17 | 확정 | 관리자는 분석, 제공자 요청 실행, 결과 검토 단계까지 취소할 수 있어야 한다. | 각 단계에서 적용을 확정하지 않고 취소할 수 있다. 이미 비용이 발생한 진행 중 외부 요청은 취소로 되돌릴 수 없음을 사용자 흐름에서 알 수 있어야 한다. |
| TR-18 | 확정 | 관리자가 적용한 값은 해당 필드의 관리자 재정의로 보호되어야 한다. | 보호는 필드 단위이며 적용하지 않은 필드에는 새 보호 상태를 만들지 않는다. |
| TR-19 | 확정 | 보호된 필드의 원본이 변경되면 그 필드의 관리자 재정의만 해제하고 일반 자동 번역을 재개해야 한다. | 원본 변경 시 해당 필드만 보호가 해제된다. 변경되지 않은 다른 필드의 관리자 값은 계속 보호된다. |
| TR-20 | 확정 | 후보 생성 후 원본이 변경된 필드에는 해당 필드의 이전 후보를 적용할 수 없어야 한다. | 원본 변경 후 해당 필드의 후보 적용이 거부되거나 무효임을 검토 흐름에서 분명히 확인할 수 있다. |
## 8. 수용 기준
- 관리자는 단일 콘텐츠의 제목·상세·태그와 시리즈의 현재 활성 연결 콘텐츠 전체의 같은 번역 필드를 대상으로 선택할 수 있다.
- 실제 제목이 정해진 EP 형식과 다르더라도 공유 구간과 고유 구간을 검토할 수 있으며, 관리자는 후보 생성 전 그룹과 구간을 수정하거나 항목을 개별 처리로 제외할 수 있다.
- 모든 등록 제공자가 각자 새로 요청되며, 제공자별 결과·실패와 후보 출처가 구분되고, 같은 후보가 묶여도 출처가 보존된다.
- 새 후보를 선택하기 전의 기존 번역은 유지되고, 관리자는 필드별로 선택할 수 있다.
- 후보 생성은 모든 세 필드와 원본 언어를 제외한 지원 언어를 대상으로 한다. 공통 제목 후보는 그룹 및 언어 단위로 적용되며, 개별 제외와 일부 선택 적용이 가능하다.
- 한 번의 일부 적용 후 요청이 닫히고 미선택 후보는 폐기된다.
- 분석·요청 실행·검토 중 취소할 수 있다. 취소는 이미 비용이 발생한 진행 중 제공자 요청을 되돌리지 않는다.
- 적용된 필드의 관리자 보호는 원본 변경 시 그 필드에 한해 해제되고, 다른 변경되지 않은 필드는 보호 상태를 유지한다.
- 후보 생성 후 원본이 변경된 필드에는 이전 후보를 적용할 수 없다.
## 9. 미결 기술 설계와 확인 경계
제품 동작 요구와 후속 설계/API 계약은 승인되었으며 9개 서버 endpoint를 구현했다. [plan-task.md](plan-task.md)에 단계별 검증과 최종 gate 보정을 기록했다. DEC-11에 따라 API와 후보 worker는 별도 설정 없이 기동 시 등록한다. 새 writer의 작업 생성 전 스키마·구 writer 종료·구 index 제거가 필요하며 프론트엔드 코드는 이번 범위 밖이다.
다음은 인터뷰에서 사용자가 선택한 제품 동작이 아니라 기술 제안이다: 제목 구간 분석·경계 규칙, 비동기 작업·부분 실패 표현, source freshness 검증, 관리자 재정의 저장과 materializer 연동, endpoint 및 프론트엔드 interaction. 세부 운영 정확도와 처리량은 실측 전까지 검증되지 않았으며 현재 제품 질문을 열어두는 이유는 아니다.
기존 번역의 제공자 출처는 불명일 수 있다. 제품 요구는 출처를 추정하지 않는 것이며, 기존 데이터의 출처 복구나 일괄 보정은 범위에 포함하지 않는다.
## 10. 요구사항 상태 및 준비도
| 구분 | 상태 |
|---|---|
| 제품 요구사항 | 인터뷰 결정으로 확정 |
| 기술 설계 및 기존 시스템 연동 | 구현·로컬 검증 완료 |
| API 계약 | 9개 endpoint 구현, 실제 HTTP 검증 완료 |
| 구현 계획/TASK | P1~P5 및 P7-T1 로컬 구현·검증 완료, P7-GATE 대기, 운영 checklist 별도 |
| 구현 | P1~P5 최종 gate APPROVE, P7 별도 검토 대기, 운영 DDL/배포 미실행 |
요구사항 명확도 점수는 인터뷰 단계의 휴리스틱 평가다. 모호성 0.10, 목표 0.95, 범위 0.95, 제약 0.90, 성공 기준 0.90, 기존 맥락 0.75. 이 점수는 기술 설계 완료나 구현 착수를 뜻하지 않는다.
## 11. 인터뷰 결정 로그
| 날짜 | ID | 상태 | 결정 | 영향 |
|---|---|---|---|---|
| 2026-11-17 | DEC-01 | 정정 전 제안 | 단일 콘텐츠는 제목·상세·태그, 시리즈는 연결 콘텐츠의 같은 필드를 대상으로 한다. 초안의 비활성 포함은 사용자 확인 없이 추가된 제안이었으며 DEC-09로 정정한다. | TR-01, TR-02 |
| 2026-11-17 | DEC-02 | 확정 | 모든 필드와 원본 언어 외 지원 언어의 후보 생성을 요청하고, 등록된 제공자를 독립적으로 새로 호출한다. 적용 전까지 기존 값을 유지한다. 같은 후보는 출처를 보존해 묶을 수 있고, 실패를 표시한다. 기존 출처는 알 수 없을 수 있다. | TR-07~TR-12 |
| 2026-11-17 | DEC-03 | 확정 | 원본 언어가 사용 가능하면 사용하고, 맞는 값을 일상적으로 재감지하지 않는다. | TR-13 |
| 2026-11-17 | DEC-04 | 확정 | 제목은 고정 EP parsing이 아니라 실제 제목의 반복 공유 구간과 고유 구간을 분석한다. 생성 전에 관리자가 원문 그룹·구간을 수정하고 항목을 개별 처리로 제외할 수 있다. | TR-03~TR-06 |
| 2026-11-17 | DEC-05 | 확정 | 후보 생성은 전체 대상 필드·지원 언어를 포함한다. 관리자는 필드별 후보를 선택하며 공통 제목은 그룹 및 언어 단위로 함께 선택·적용한다. 개별 제외는 생성 전에 한다. | TR-07, TR-09, TR-14, TR-15 |
| 2026-11-17 | DEC-06 | 확정·보완 | 일부 선택 적용과 적용 전 취소를 허용한다. 미선택 번역 값은 유지하며 이미 전송된 요청 비용은 되돌릴 수 없다. 한 번 적용 후 종료 정책은 후속 DEC-10에서 별도로 확정했다. | TR-16, TR-17 |
| 2026-11-17 | DEC-07 | 확정 | 적용된 관리자 보호는 필드별이다. 원본 변경 시 변경된 필드만 보호를 풀고 자동 번역을 재개하며, 변경되지 않은 필드는 보호한다. 후보 생성 후 원본이 바뀐 필드에는 해당 필드의 이전 후보를 적용할 수 없다. | TR-18~TR-20 |
| 2026-11-17 | DEC-08 | 확정 | 이번 문서 범위는 요구사항과 별도 제안 설계다. 설계/API 계약/계획은 사용자 검토 전 제안 상태이고 구현은 시작하지 않는다. | 문서 상태, 후속 문서 링크 |
| 2026-11-17 | DEC-09 | 확정 | 추가 인터뷰에서 시리즈는 활성 콘텐츠만 포함하기로 선택했다. 비활성 콘텐츠는 제목 분석·후보 생성에서 제외한다. | TR-02, DEC-01 정정 |
| 2026-11-17 | DEC-10 | 확정 | 추가 인터뷰에서 한 번 적용하면 요청을 종료하고 미선택 후보는 폐기하기로 선택했다. 다른 결과를 적용하려면 새 요청을 생성한다. | TR-16, DEC-06 보완 |
| 2026-11-18 | DEC-11 | 확정 | 사용자가 enabled=false 설정을 제거하고 배포 시 바로 사용할 수 있도록 요청했다. 활성화 property와 controller/worker 조건부 등록, 해당 플래그의 일반 큐 legacy 호환 분기를 제거한다. ADMIN 권한·기존 worker 잠금·주기는 유지한다. | P7-T1, 이전 OFF→ON 운영 안내 대체 |
DEC-11부터 관리자 번역 기능은 설정 없이 애플리케이션 기동 시 등록한다. 스키마가 자동으로 변경되지는 않는다. 신규 writer가 작업을 생성하기 전 신규 테이블·언어 포함 unique index를 준비하고, 구 writer/in-flight 작업 종료 및 구 unique index 제거를 완료해야 한다. 운영 변경은 이번 코드 수정의 실행 범위가 아니다. 이전 실행 기록의 기본 OFF 안내는 당시 상태이며 현재 정책은 DEC-11이다.
## 12. 승인 및 실행 기록
| 날짜 | 상태 | 기록 |
|---|---|---|
| 2026-11-17 | 설계 승인 및 구현 승인 | 사용자가 설계 승인 후 구현 시작을 명시적으로 선택했다. 승인은 로컬 서버 구현과 focused tests에 한정되며 production DDL/deploy/git commit은 승인 범위가 아니다. 활성-only series 구성원, one-shot subset apply, 자유 형식 번역문 제외 결정을 유지한다. 실행 기준은 기존 plan의 Progress 실행 ledger이며 새 계획이나 workspace를 만들지 않는다. 현재 workspace는 기존 test branch이고 P1 구현 담당자가 source와 plan을 읽는다. 이 문서 갱신 시점에 완료된 구현 Goal은 없다. |
| 2026-11-17 | 로컬 구현 완료 | P1~P5·최종 gate 보정 완료. 마지막 실제 HTTP 27개와 bootJar 통과, 관련 회귀와 ktlintCheck 통과, 최종 제한 검토 APPROVE. 운영 적용은 실행하지 않았다. |
| 2026-11-18 | DEC-11 로컬 구현·검증 완료 | P7-T1의 등록·언어 identity RED 4개 assertion 실패 후 플래그·legacy 분기·고아 조회를 제거했다. 직접 영향 18개 class 162개 테스트와 ktlintCheck 통과. P7-GATE는 부모 검토 대기이며 운영 DDL·배포·커밋은 미실행이다. |
@@ -0,0 +1,35 @@
# 관리자 번역 후보 설계 검토
> 이 문서는 2026-11-17 설계 검토 이력이다. DR-03의 OFF 호환 모드와 flag 전환 정책은 2026-11-18 PRD DEC-11/P7로 대체됐다. 현재는 기동 시 자동 등록하며, 새 writer 작업 생성 전에 세 테이블·언어 포함 unique index 준비, 구 writer/in-flight 종료, 구 index 제거가 필요하다. 아래 과거 판정은 보존한다.
## 범위와 판정
- 일자: 2026-11-17.
- 대상: [PRD](../prd.md), [API 계약](../api-contract.md), [구현 계획](../plan-task.md).
- 독립 검토: Oracle 한 차례, 문서와 관련 기존 코드 읽기만 수행.
- 판정: 아래 지적 보정 후 설계 산출물 수용 가능. 제품 구현 완료 또는 사용자 구현 승인을 의미하지 않는다.
## 지적 및 반영
| ID | 중요도 | 확인한 문제 | 보정 내용 |
|---|---|---|---|
| DR-01 | 높음 | 비활성 포함·한 번 적용 후 종료를 인터뷰 확정으로 잘못 기록 | 후속 인터뷰에서 활성 콘텐츠만 포함, 한 번 적용 후 종료를 직접 확인했다. PRD DEC-09/10으로 정정했다. 자유 번역문 입력 제외는 요청 범위 제안으로 구분했다. |
| DR-02 | 높음 | API apply 설명이 source 검증 후 잠금을 획득 | request → Series → CONTENT 잠금 후 최신 source·membership·override·payload를 재조회·검증하도록 통일했다. |
| DR-03 | 높음 | source-language-aware lookup과 구 unique index가 혼재하면 insert 충돌 | 새 코드의 disabled 호환 모드는 exact-language 조회 후 legacy-key exists 확인으로 기존 mismatch skip을 보존한다. 구 writer 제거와 구 index 삭제 후에만 enabled=true로 활성화한다. 호환 모드도 단일 row legacy 조회를 하지 않는다. |
| DR-04 | 중간 | 취소의 실제 전송/dispatch 승인 기준 및 network 대기 설명 충돌 | DB 취소 commit 이후 새 승인·게시 금지로 통일했다. 이미 승인된 호출은 in-flight이고, 취소 응답은 network 종료를 기다리지 않는다. |
| DR-05 | 중간 | grouping/segment/candidate 배열 대응 및 preview 계약 부족 | GroupingResponse/TitleTemplate/TitleSegment, code-point index, shared/residual valueIndex, input/output cardinality, receipt 타입을 정의했다. |
| DR-06 | 중간 | PREPARING의 durable 실행·재시작·취소가 불명확 | 요청과 활성 member IDs를 먼저 저장하고 동일 poller가 preparation lease/fence를 claim한다. 복구 1회, snapshot 게시 전 취소·source 검증, 반복 만료의 명시 실패를 정의했다. |
| DR-07 | 중간 | replay 우선순위 및 frozen provider version 검사가 누락 | 저장된 generation revision/apply operation replay를 최신 revision 거부보다 먼저 확인하고 provider ID/version 변경은 명시 실패로 처리한다. |
## 추가 정합성 보정
- CONTENT materializer는 유효한 관리자 override가 있으면 해당 필드의 shared memory가 없어도 승인 값을 사용할 수 있도록 순서를 명시했다.
- API의 잘못된 계획 anchor, source snapshot/현재 값 구분, 삭제·비활성화 후 자격 검증을 보완했다.
- 위 수정은 문서만 변경했다. 신규 endpoint, DDL, source, test는 구현하지 않았다.
## 검증 범위
- 부모 에이전트가 세 문서를 읽고 요구사항·API·계획을 대조했다.
- 공백 검사와 최종 변경 파일 확인 결과는 구현 계획의 문서 검증 기록에 남긴다.
- 실행하지 않음: 애플리케이션/테스트/빌드, 운영 DB·MySQL 잠금 검증, 실제 AWS·파파고 호출, 프론트엔드 QA.
- 남은 항목: 사용자 기술 설계 검토와 별도 구현 승인. 실제 제목 분석 정확도·처리량·provider timeout은 계획의 focused 검증에서 확인한다.
@@ -0,0 +1,74 @@
# 관리자 번역 선택 구현 검토 및 QA
## 범위와 현재 판정
- 목표: 관리자 단건/활성 시리즈 콘텐츠의 provider별 새 후보 비교·선택, 제목 공통 구간 검토, 취소, 부분 원자 적용 및 필드별 승인 보호.
- 범위: 서버 코드·API 계약·DDL 배포 준비. 실제 프론트엔드·운영 DB 반영·배포·커밋은 제외한다.
- P1~P4 작업별 검토와 P5를 포함한 단일 전체 gate, 차단 한 건 보정 후 새 delta 검토를 완료했다.
- P1~P5 최종 판정: **APPROVE / HIGH**. 후속 DEC-11/P7은 사용자 지시에 따라 부모가 직접 코드·검증 기록·문서를 검토하고 최신 bootJar를 빌드해 완료했다. P7의 외부 승인으로 표현하지 않는다. 운영 MySQL/cloud 검증은 수행하지 않았다.
> 아래 2026-11-17 검증·판정은 당시 이력이다. 기본 OFF 및 flag 전환 정책은 PRD DEC-11/P7로 대체됐으며 기존 PASS 기록은 재작성하지 않는다.
- 후속 P7-T1 로컬 증거: 등록·언어 identity RED 4개 실패 후 직접 영향 18개 class 162개 테스트 및 ktlintCheck 통과. 부모가 직접 검토하고 `./gradlew --offline --no-daemon bootJar`의 BUILD SUCCESSFUL 및 JAR 생성을 확인했다. 상세 명령·이력·한계는 `plan-task.md` P7-GATE 기록에 있다.
## 최종 트리에서 부모 에이전트가 실행한 검증
```bash
./gradlew --no-daemon test \
--tests 'kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionHttpIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionApplyHttpIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionReceiptHttpIntegrationTest' \
bootJar
```
- 결과: BUILD SUCCESSFUL in 50s, 종료 코드 0. 실제 로컬 HTTP 서버와 H2/fake providers를 사용한 14+10+3 = 27개 테스트, 실패/오류/skip 0.
- 마지막 writer overload 수정 이후 최종 HTTP 흐름을 부모가 직접 실행했다. 브라우저 수동 QA나 실제 AWS/Papago 번역 품질 검증으로 표현하지 않는다.
- 산출물: `build/libs/sodalive-0.0.1-SNAPSHOT.jar` 생성 확인.
- 증거 root: `build/test-results/test/`. 아래 A/B/C는 그 디렉터리의 XML 파일이다.
- A: `TEST-kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionHttpIntegrationTest.xml`
- B: `TEST-kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionApplyHttpIntegrationTest.xml`
- C: `TEST-kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionReceiptHttpIntegrationTest.xml`
## 실제 HTTP QA 행렬
| 시나리오 | 실행/기대 | 관찰 결과 | 판정·증거 |
|---|---|---|---|
| 단건 전체 흐름 | 생성→준비→후보 생성→일부 선택→receipt/출처 재조회 | 선택 필드만 적용되고 출처·receipt가 조회됨 | PASS, A의 실제 HTTP 전체 흐름 case |
| 시리즈 여러 그룹·개별 제목 | 그룹 수정·검토→생성→공통 후보+member별 residual 선택 | 그룹별 동일 공통 표기, 선택 언어와 개별 제목만 반영, 미선택 폐기 | PASS, B의 multiple groups case |
| 잘못된 그룹 선택 | member residual 누락 후 apply | INCOMPLETE_TITLE_GROUP, override 0건, 정상 선택 재전송은 성공 | PASS, B multiple groups case |
| 원문 변경·후보 오류 | 후보 생성 후 raw 공백 변경, 없는 candidate, 잘못된 언어/ID | SOURCE_CHANGED/CANDIDATE_NOT_SELECTABLE/INVALID_REQUEST, 승인 쓰기 0건 | PASS, B의 오류 9개 parameter cases |
| 사전 검토·편집 제약 | series 검토 전 generate, all-individual review, 생성 후 편집 | REVIEW_REQUIRED/호출0, 검토 revision 증가, 생성 후 편집 거부 | PASS, A의 review cases |
| 권한 | CONTENT_MANAGER/CREATOR/USER로 관리 action | ADMIN 외 역할 거부 | PASS, A의 role 3개 cases |
| 취소 | revision 없이 취소 후 재전송 및 취소된 request apply | 같은 terminal 취소 결과, REQUEST_CLOSED, 적용 없음 | PASS, A cancel 및 B closed case |
| Unicode/원문 재구성 | code-point/grapheme 범위와 template 조회 | raw 원문·residual 구문 보존, 잘못된 범위 거부 | PASS, A template/group cases |
| 시각/재전송 불변성 | 나노초 0/123456789/999999999, DB flush/clear, 원문 변경 뒤 receipt 조회 | DB·HTTP 시각은 초 정밀도로 일치, receipt/replay 불변 | PASS, C 3개 cases |
| P5 부분 적용 후 일반 자동 갱신 회귀 | 실제 title/detail apply→일반 title 수정→일반 worker; tags memory 없음·캐시 존재 및 provider 부분 실패 | 성공 title 게시·job 완료, detail 승인·미선택 tags 바이트 보존, 새 payload는 완성 전 job 미완료 | 로컬 회귀 PASS, `TranslationSelectionRefreshIntegrationTest` 3개 RED→4개 GREEN; 직접 회귀 118개 및 최종 lint 통과. 부모 delta 검토·관리 HTTP/bootJar 새 검증 대기. `plan-task.md` P5-R1 참조 |
| 실행 산출물 | bootJar | JVM 실행용 jar 생성 | PASS, `build/libs/sodalive-0.0.1-SNAPSHOT.jar` |
## 기존 집중 회귀 증거
- 필드 승인 보호·원문 변경·동시 materializer·queue refresh: plan-task.md P2 기록과 해당 통합 테스트.
- PREPARING 복구·취소·활성 scope·기본 비활성: P3 68개 focused 증거 및 독립 PASS.
- Provider별 fresh 후보·linked dedup·lease/fence·실제 SDK HTTP retry 취소: P4 기록 및 독립 PASS.
- P5 추가 source/group/cancel/apply concurrency와 transaction rollback: P5 56개 신규 cases를 포함한 관련 170개 검증 이력. 최초 20개 실패의 원인과 직접 영향 42개 재검증을 구분해 기록했다.
- 전체 테스트를 실행하지 않았다. 사용자 전체 테스트 명령은 `./gradlew test`다.
## 운영 한계
- H2 테스트는 운영 MySQL REPEATABLE READ·DDL·잠금·timestamp 검증의 대체물이 아니다.
- DEC-11에 따라 API와 후보 worker는 설정 없이 기동 시 등록된다. 신규 writer 작업 생성 전 세 테이블·언어 포함 queue unique index를 준비하고 구 writer/in-flight 작업 종료 및 구 queue unique index 제거를 완료해야 한다. 자동 DDL이나 기능 활성화 단계는 없다.
- 이미 전송 승인을 받은 provider 호출은 취소 이후에도 비용이 발생할 수 있다. 요청별 timeout은 절대적인 실시간 중단 보장이 아니다.
- 운영 DDL 실행·배포 및 커밋은 수행하지 않았다.
## 최종 gate 보정 후 HTTP 재검증
- 최초 전체 gate는 TR-19의 부분 승인 후 자동 갱신 결함 한 건으로 REJECT했다. 기존 payload의 명시된 필드만 재료화하는 경계를 추가하고 신규 전체 payload의 엄격한 완료 조건은 유지했다.
- 수정자는 실제 apply → 일반 원문 수정 → 일반 worker의 RED 3개를 확인했다. 신규 회귀 4개와 직접 영향 118개가 통과했고 lint도 통과했다. 자세한 범위는 `plan-task.md` P5-R1에 기록했다.
- 부모가 보정 후 위와 동일한 실제 HTTP 세 클래스 및 `bootJar` 명령을 직접 실행했다. 결과: BUILD SUCCESSFUL in 2m 7s, 종료 코드 0. 테스트와 jar는 보정된 최종 코드 기준이다.
- 최종 판정은 보정 delta와 현재 증거의 새 제한 검토 결과를 아래에 추가한다. 기존 전체 검토에서 통과한 다른 범위를 다시 확대 검토하지 않는다.
### 최종 판정 기록
- 새 Oracle의 delta 검토: APPROVE, HIGH. 기존 locale의 명시 필드만 갱신하고 신규/전체 payload의 엄격한 완료 조건은 유지함을 확인했다. CONTENT 게시와 job 완료의 동일 transaction, provider 부분 실패 및 비-CONTENT 분기 보존도 확인했다.
- 최신 HTTP XML 14+10+3=27개 오류/실패/skip 0, jar 존재를 검토자가 확인했다. 회귀 4+118와 lint의 근거는 P5-R1 기록으로 구분했다.
- 모든 로컬 차단 finding은 해결됐다. 위 QA 행의 재검증 대기 표기는 이 후속 판정으로 종결하며, 운영 검증 대기는 해결했다고 표시하지 않는다.
@@ -0,0 +1,80 @@
-- Schema artifact for the implemented admin translation selection feature.
-- Do not execute against production without operator approval; no automatic DDL is performed by the application.
-- DEC-11: API and candidate worker register at startup without an activation flag.
-- Before new writers create any jobs, prepare all three tables and the language-aware unique index,
-- drain every legacy writer and in-flight job, then complete the separate old-index removal below.
CREATE TABLE content_translation_override (
id BIGINT NOT NULL AUTO_INCREMENT COMMENT '승인 override 식별자',
content_id BIGINT NOT NULL COMMENT '기존 콘텐츠 식별자, 삭제 cascade 없음',
locale VARCHAR(10) NOT NULL COMMENT '승인 대상 언어',
field_key VARCHAR(10) NOT NULL COMMENT 'TITLE, DETAIL, TAGS 중 승인 필드',
source_fingerprint VARCHAR(67) NOT NULL COMMENT '원본 언어와 정확한 필드 원문의 버전 포함 fingerprint',
approved_text TEXT NOT NULL COMMENT '관리자가 선택한 번역 문자열',
provenance TEXT NOT NULL COMMENT 'JSON 출처: requestId, candidateIds 목록, providers id/version 목록, approvedBy; 후보 FK 없음',
approved_at TIMESTAMP NOT NULL COMMENT 'UTC 초 정밀도로 한 번 정규화한 승인 시각',
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
PRIMARY KEY (id),
UNIQUE KEY uk_content_translation_override_field (content_id, locale, field_key)
) COMMENT='콘텐츠 언어별 필드 승인과 출처, 전역 번역 메모리와 독립';
-- Expand: keep uk_translation_job_resource_field_target_hash until every old writer and in-flight job is drained.
ALTER TABLE translation_job
ADD UNIQUE KEY uk_translation_job_resource_field_target_hash_language
(resource_type, resource_id, field_key, target_language, source_hash, source_language);
-- Contract (separate operator-approved step after legacy drain, required before new writers start work):
-- ALTER TABLE translation_job DROP INDEX uk_translation_job_resource_field_target_hash;
-- New writers always use exact source-language identity; there is no legacy-index compatibility mode.
-- After the first approval, rollback only to an override-aware application version. No DDL in this file was executed.
-- Request state, reviewed source/group snapshots, and the atomic apply receipt.
CREATE TABLE translation_selection_request (
id BIGINT NOT NULL AUTO_INCREMENT COMMENT '관리자 번역 선택 요청 식별자',
created_by BIGINT NOT NULL COMMENT '생성한 관리자 식별자',
client_request_id VARCHAR(36) NOT NULL COMMENT '관리자 범위 생성 멱등 UUID',
body_hash VARCHAR(64) NOT NULL COMMENT '버전 포함 canonical scope 본문 SHA-256',
scope TEXT NOT NULL COMMENT 'CONTENT 또는 SERIES 및 Long 식별자의 typed JSON',
status VARCHAR(24) NOT NULL COMMENT 'PREPARING REVIEW_REQUIRED READY_TO_GENERATE GENERATING READY APPLIED CANCELLED FAILED',
revision BIGINT NOT NULL COMMENT '관리자 의미 변경 revision, 최초 1',
snapshot LONGTEXT NOT NULL COMMENT '버전 JSON: 고정 활성 member IDs, 준비 원문, 확정 원문, reviewed 원문 그룹, provider ID/version manifest, 대상 언어, generation units',
preparation_attempt INT NOT NULL COMMENT '준비 실행 횟수, 최초 실행과 복구 1회까지',
preparation_lease_until TIMESTAMP NULL COMMENT '준비 소유권 UTC 초 만료 시각, lease 60초',
preparation_fence BIGINT NOT NULL COMMENT '오래된 실행의 게시와 갱신을 거부하는 단조 fence',
error_code VARCHAR(40) NULL COMMENT '준비 실패 안정 코드, 외부 예외 본문 없음',
accepted_generate_revision BIGINT NULL COMMENT '후속 후보 생성에서 수락한 revision',
apply_operation_id VARCHAR(36) NULL COMMENT '후속 one-shot 적용 멱등 UUID',
apply_body_hash VARCHAR(64) NULL COMMENT '후속 적용 canonical 본문 SHA-256',
apply_receipt LONGTEXT NULL COMMENT '후속 적용과 동일 transaction에 저장할 버전 JSON 영수증',
applied_at TIMESTAMP NULL COMMENT '후속 적용 UTC 초 확정 시각',
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
PRIMARY KEY (id),
UNIQUE KEY uk_translation_selection_creation (created_by, client_request_id),
KEY ix_translation_selection_prepare (status, preparation_lease_until, id)
) COMMENT='관리자 번역 선택 요청과 고정 원문 및 그룹 검토, 일반 번역 작업과 독립';
CREATE TABLE translation_candidate (
id BIGINT NOT NULL AUTO_INCREMENT COMMENT '제공자별 후보 식별자',
request_id BIGINT NOT NULL COMMENT '동결 manifest를 소유한 관리자 번역 요청',
unit_key VARCHAR(160) NOT NULL COMMENT '요청 안의 결정적 FIELD GROUP_COMMON TITLE_RESIDUAL 단위 키',
unit LONGTEXT NOT NULL COMMENT 'JSON: kind, sourceLanguage, 정확한 inputValues 순서, field/content/group 소유권',
provider_id VARCHAR(20) NOT NULL COMMENT '동결된 제공자 ID, fallback 대체 없음',
provider_version VARCHAR(80) NOT NULL COMMENT '동결된 제공자 버전, dispatch 시 일치 검사',
target_language VARCHAR(10) NOT NULL COMMENT 'source를 제외한 ko en ja 대상 언어',
status VARCHAR(16) NOT NULL COMMENT 'PENDING RUNNING SUCCEEDED FAILED DISCARDED',
translated_values LONGTEXT NULL COMMENT '입력 인덱스와 일치하는 JSON 번역 문자열 배열, 실패/폐기는 NULL',
failure_code VARCHAR(40) NULL COMMENT '안정 실패 코드, 외부 응답/예외 원문은 저장하지 않음',
attempt INT NOT NULL COMMENT '실제 provider 작업 claim 횟수, 최대 2, linked 결과는 별도 전송 없음',
lease_until TIMESTAMP NULL COMMENT '소유권 UTC 초 만료, 60초 lease, 만료 fence의 연장 금지',
fence BIGINT NOT NULL COMMENT 'claim/취소의 단조 fencing token',
linked_candidate_id BIGINT NULL COMMENT '같은 요청 제공자 언어 원문 배열의 선행 후보, 단위 소유권은 이 row에 보존',
terminal_at TIMESTAMP NULL COMMENT '성공 실패 폐기의 UTC 초 확정 시각',
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
PRIMARY KEY (id),
UNIQUE KEY uk_translation_candidate_unit (request_id, unit_key, provider_id, target_language),
KEY ix_translation_candidate_claim (request_id, status, lease_until, id),
CONSTRAINT fk_translation_candidate_request FOREIGN KEY (request_id)
REFERENCES translation_selection_request (id) ON DELETE RESTRICT
) COMMENT='관리자 요청별 fresh provider 후보와 durable 실행 결과, 게시 번역 및 전역 memory와 독립';
@@ -0,0 +1,124 @@
# 관리자 배너 통합 테스트 컨텍스트 오류 구현 계획
| 문서 항목 | 내용 |
|---|---|
| 상태 | 구현 완료 |
| 작성일 | 2026-11-18 |
| 요구사항 기준 | [prd.md](prd.md) |
| API 기준 | 해당 없음 |
| 현재 Phase | Phase 1: 테스트 설정 스캔 범위 수정 |
| 현재 활성 Goal | 없음 |
## 목표
관리자 배너 통합 테스트가 테스트 전용 설정의 전역 스캔으로 인한 보안 advisor 중복 없이 실행되도록 한다.
## 현재 상태
| Phase | 상태 | 완료 Task | 활성/다음 Goal | 차단 또는 남은 조건 |
|---:|---|---:|---|---|
| 1 | 완료 | `1/1` | 없음 | 지정 회귀 테스트 통과 |
## 범위
### 포함
- `SelectionCandidateProviderConfiguration`도 전역 스캔에서 제외하되, `TranslationCandidateTestSupport` 등의 명시적 `@Import`는 유지한다.
- `TranslationSelectionTestConfiguration`을 컴포넌트 스캔에서 제외되는 테스트 컴포넌트로 표시.
- 두 관리자 배너 테스트와 해당 설정을 사용하는 번역 선택 테스트 실행.
### 제외
- API 또는 애플리케이션 보안 설정 변경.
- 테스트 assertion 변경 및 전체 테스트 실행.
## 기술적 제약 및 검증
- Spring Boot 2.7.14 및 기존 Kotlin 테스트 설정 패턴을 따른다.
- 명시적으로 `TranslationSelectionTestConfiguration`을 지정하는 테스트의 설정 동작을 유지한다.
- 테스트는 `--tests`로 대상 클래스를 지정하며 전체 테스트는 사용자가 실행한다.
### Phase 1: 테스트 설정 스캔 범위 수정
**Phase 결과:** 테스트 전용 번역 설정이 전역 스캔에 참여하지 않으며, 배너 및 번역 선택 테스트가 통과한다.
**선행조건:** 제공된 구현 계획의 원인과 수정 지점을 확인한다.
**Phase 완료 조건:** `P1-T1` 및 `P1-GATE` 완료, 검증 기록 누적.
### 구현 항목
- [x] **Task 1.1: 테스트 설정을 컴포넌트 스캔에서 제외**
**Goal 실행 `P1-T1`:** 두 테스트 전용 설정을 컴포넌트 스캔에서 제외하면서 명시적 테스트 설정 사용은 유지한다.
- **시작 조건:** 두 관리자 배너 테스트가 컨텍스트 초기화 오류로 실패함을 확인.
- **완료 증거:** 최소 설정 변경 및 배너/번역 선택 테스트 통과.
- **범위 밖:** API와 보안 설정 변경, 테스트 assertion 완화.
**Files:**
- Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/contenttranslation/application/TranslationSelectionTestConfiguration.kt`
- Modify: `src/test/kotlin/kr/co/vividnext/sodalive/v2/contenttranslation/application/TranslationCandidateTestSupport.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/admin/chat/AdminChatBannerControllerIntegrationTest.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/admin/content/banner/AdminContentBannerControllerIntegrationTest.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/contenttranslation/application/TranslationSelectionRequestIntegrationTest.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/contenttranslation/application/TranslationSelectionWorkerIntegrationTest.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/contenttranslation/application/TranslationSelectionCandidateLifecycleIntegrationTest.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/contenttranslation/adapter/in/web`의 `TranslationSelectionHttpTestSupport` 하위 테스트
**Interfaces:**
- Consumes: Spring Boot의 `@TestComponent` 스캔 제외 동작.
- Produces: 앱 전체 `@SpringBootTest`에는 포함되지 않고 명시적 `classes = [TranslationSelectionTestConfiguration::class]`에서는 계속 로드되는 설정.
- [x] **RED:** 기존 두 관리자 배너 통합 테스트를 재현 테스트로 사용한다. 추가 테스트 없이 실제 테스트의 컨텍스트 로딩 실패를 확인했다.
- [x] **RED 확인:** `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.admin.chat.AdminChatBannerControllerIntegrationTest' --tests 'kr.co.vividnext.sodalive.admin.content.banner.AdminContentBannerControllerIntegrationTest'` 실행 결과 73개가 `BeanDefinitionOverrideException`을 포함한 컨텍스트 초기화 실패로 종료했다.
- [x] **GREEN:** `TranslationSelectionTestConfiguration`에 `@TestComponent`를 추가한다.
- [x] **GREEN:** `SelectionCandidateProviderConfiguration`에도 `@TestComponent`를 추가하고, 명시적 `@Import` 사용을 유지한다.
- [x] **GREEN 확인:** 위 배너 테스트와 설정을 사용하는 번역 선택 테스트를 실행해 통과를 확인한다.
- [x] **REFACTOR:** 변경 범위의 직접 영향 회귀 테스트를 실행하고 결과를 아래 Progress에 기록한다.
### 완료 조건
- [x] `P1-T1`의 실행 체크박스와 완료 증거가 충족됐다.
- [x] 전역 앱 컨텍스트와 명시적 번역 테스트 컨텍스트의 설정 경계가 검증됐다.
### 검증 방법
#### Phase 1 Gate
**Goal 실행 `P1-GATE`:** 배너 테스트와 테스트 전용 설정을 사용하는 번역 선택 회귀 범위를 검증한다.
- **Objective:** 전역 스캔 제외 및 명시적 테스트 설정 사용이 모두 확인된 상태로 작업을 마친다.
- **시작 조건:** `P1-T1` 완료.
- **완료 증거:** 두 배너 테스트와 설정 사용 번역 테스트 통과, 검증 결과 기록.
- **범위 밖:** 전체 테스트 실행.
```bash
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.admin.chat.AdminChatBannerControllerIntegrationTest' --tests 'kr.co.vividnext.sodalive.admin.content.banner.AdminContentBannerControllerIntegrationTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionRequestIntegrationTest' --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionWorkerIntegrationTest' --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionContentsHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.TranslationSelectionActivationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionApplyHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.adapter.in.web.AdminTranslationSelectionReceiptHttpIntegrationTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionCandidateLifecycleIntegrationTest'
```
**Expected:** 모든 지정 테스트 성공. 전체 테스트는 사용자가 `./gradlew test`로 실행한다.
## Progress
- RED: 배너 테스트 73개가 공통으로 컨텍스트 초기화 실패. 구현 전 재현.
- GREEN: `TranslationSelectionTestConfiguration`에 `@TestComponent`를 추가. 실행 후 결과를 이어서 기록한다.
### `P1-T1` 1차 실행 — 2026-11-18
- 상태: 완료
- 무엇을: 두 테스트 전용 설정(`TranslationSelectionTestConfiguration`, `SelectionCandidateProviderConfiguration`)에 `@TestComponent` 추가.
- 왜: 1차 수정 후 재실행 시 `metaDataSourceAdvisor` 충돌은 사라졌지만, 전역 스캔된 `SelectionCandidateProviderConfiguration`의 `SelectionPapagoProvider`가 운영 `PapagoTranslationService`와 `PAPAGO` ID가 겹쳐 `LanguageProviderProperties.kt:18`의 `duplicate registered language provider name` 예외가 발생했다.
- 어떻게:
- `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.admin.chat.AdminChatBannerControllerIntegrationTest' --tests 'kr.co.vividnext.sodalive.admin.content.banner.AdminContentBannerControllerIntegrationTest'` (1차 수정만 적용) — 실패, provider ID 중복 예외 및 600초 timeout.
- `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.admin.chat.AdminChatBannerControllerIntegrationTest'` — 성공.
- `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.admin.content.banner.AdminContentBannerControllerIntegrationTest'` — 성공.
- Phase 1 Gate의 번역 선택 회귀 6개 클래스 명령 — 성공.
- `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionCandidateLifecycleIntegrationTest'` — 성공.
- `git diff --check` — 공백 오류 없음.
- 남은 항목: 전체 테스트는 미실행. 사용자가 `./gradlew test`로 직접 실행한다.
@@ -0,0 +1,49 @@
# 관리자 배너 통합 테스트 컨텍스트 오류 PRD
## 문서 정보
| 항목 | 내용 |
|---|---|
| 문서 상태 | 구현 완료 |
| 작성일 | 2026-11-18 |
| 최종 수정일 | 2026-11-18 |
| 대상 제품 | 관리자 배너 통합 테스트 |
| 작성자·결정권자 | 사용자 요청 및 제공된 구현 계획 |
| 관련 API Contract | 해당 없음 (공개 API 변경 없음) |
| 관련 구현 계획 | [plan-task.md](plan-task.md) |
| 관련 review | 없음 |
### 요구사항 상태
| ID | 상태 | 요구사항 | 구현 처리 |
|---|---|---|---|
| `REQ-001` | 확정 | 테스트 전용 번역 설정은 앱의 전역 컴포넌트 스캔에서 제외하되, 해당 설정을 지정하는 번역 테스트에서는 계속 사용할 수 있어야 한다. | `plan-task.md`의 `P1-T1` 및 테스트 증거로 추적 |
## 1. Overview
관리자 채팅 배너와 콘텐츠 배너 통합 테스트는 테스트 전용 설정들이 전역 컴포넌트 스캔에 참여해 Spring 컨텍스트를 생성하지 못한다. 테스트 전용 설정들을 전역 스캔에서 제외한다.
## 2. Problem Statement
- `SelectionCandidateProviderConfiguration`도 테스트 클래스패스에서 전역 스캔되어 `SelectionPapagoProvider`를 등록하고, 운영 `PAPAGO` provider와 ID가 중복된다.
- 두 배너 통합 테스트는 각 테스트 실행에서 Spring 컨텍스트 초기화 중 `BeanDefinitionOverrideException`으로 실패한다.
- 테스트 전용 `TranslationSelectionTestConfiguration`이 앱 패키지 아래의 `@Configuration`으로 탐색되어 애플리케이션 보안 설정과 중복 등록된다.
- 해결 여부는 두 배너 테스트와 해당 설정을 명시적으로 사용하는 번역 선택 테스트의 통과로 판단한다.
## 3. Goals
- 테스트 전용 설정을 전체 애플리케이션의 컴포넌트 스캔에서 제외한다.
- 번역 선택 테스트가 해당 설정을 직접 지정할 때는 기존 테스트 구성을 계속 사용한다.
- 관리자 배너 테스트와 영향받는 번역 선택 테스트를 실행해 결과를 확인한다.
## 4. Non-Goals
- 공개 API, 보안 정책, 애플리케이션 런타임 설정 변경.
- 관리자 배너 테스트의 assertion 또는 테스트 범위 완화.
## 5. 수용 기준
- `AdminChatBannerControllerIntegrationTest`와 `AdminContentBannerControllerIntegrationTest`가 통과한다.
- `TranslationSelectionTestConfiguration`을 사용하는 지정 테스트가 통과한다.
- 수정은 테스트 설정의 스캔 제외에 한정한다.
@@ -0,0 +1,242 @@
# 번역 및 관리자 오디오 테스트 수정 계획
- 작성일: 2026-11-18
- 기준: [prd.md](prd.md)
- 상태: P6 buildSrc Kotlin 통일, 58개 정책/33개 focused/lint/API/리뷰 검증 및 정리 완료. 실제 Jenkins와 전체 suite 재실행은 미수행.
- 활성 Goal: 없음
## P1-T1: 실패 원인 재현과 최소 테스트 수정
- 시작 조건: 사용자 지정 테스트와 운영 생성자/호출 경로를 읽는다.
- 완료 증거: 재현 오류, 테스트 전용 diff, 네 클래스 통과.
- 범위 밖: 운영 로직 변경 및 기존 assertion 약화.
- 대상 파일:
- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderSpringConfigurationTest.kt`
- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt`
- `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/AiCharacterAdminAudioContentControllerTest.kt`
- `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/AiCharacterAdminAudioContentOwnershipTest.kt`
- TDD 예외: 신규 운영 동작이 아닌 기존 테스트 fixture/config 수정이다. 기존 실패 테스트를 재현 증거로 재사용한다.
- [x] 기존 테스트 의도와 운영 의존성 확인.
- [x] 실패 오류를 실행으로 확정.
- [x] 최소 테스트 설정/fixture 수정.
- [x] 같은 테스트 통과 확인.
```bash
./gradlew test --tests '*LanguageProviderSpringConfigurationTest' --tests '*OriginalWorkReadRetryTest' --tests '*AiCharacterAdminAudioContentControllerTest' --tests '*AiCharacterAdminAudioContentOwnershipTest' --console=plain
```
## P1-GATE: 회귀와 변경 범위 확인
- 시작 조건: P1-T1 통과.
- 완료 증거: 직접 관련 회귀, 변경 파일 lint/컴파일, 리뷰, 임시 자원 정리.
- [x] 번역 provider/read retry 및 관리자 오디오 직접 관련 회귀 통과.
- [x] 변경 범위와 기존 assertion 보존 리뷰.
- [x] 임시 자원 정리 및 결과 기록.
- 전체 테스트는 사용자 실행: `./gradlew test`. focused 성공을 전체 성공으로 보고하지 않는다.
## 검증 기록
- 최초 focused 실행: LanguageProviderSpringConfigurationTest startupFailure 6건, OriginalWorkReadRetryTest `single()` IllegalArgumentException 1건 확인. 200초 명령 제한으로 종료되어 관리자 테스트 및 XML 생성은 미완료.
- 수정 전 완전 재현: 같은 네 클래스, 3분 27초, exit 1. 총 77개 중 71개 실패, skip 0. LanguageProvider 7개 중 6개는 `PlatformTransactionManager` 빈 누락, OriginalWork 6개 중 1개는 `List has more than one element`, 관리자 Controller 30개와 Ownership 34개는 `CreatorAdminContentService.applicationEventPublisher` 필드가 없어 준비 단계 실패.
- 최소 수정: provider context에 기존 단위 테스트와 같은 transaction manager mock을 등록한다. 원작 테스트는 기존 ja FAILED 작업의 모든 상태 보존을 유지하면서 새 ko→en PENDING 작업의 정확한 개수·식별자·원문·초기 상태도 검증한다. 관리자 테스트는 실제 이벤트 소유 서비스와 현재 번역 무효화 경계를 검증한다.
- 관리자 두 테스트: 삭제된 CreatorAdminContentService publisher reflection만 제거하고, 실제 ContentTranslationSourceInvalidationService를 SpyBean으로 관찰해 거부 요청의 무호출을 검증한다. 정상 서비스 동작을 stub하지 않는다.
- 정적 검사: 변경 diff 공백 검사 통과. Kotlin LSP는 미설치이며 기존 설치 거부 설정 때문에 실행 불가. Gradle compileTestKotlin으로 타입/컴파일 검증을 수행한다.
- 수정 후 focused: 위 네 클래스 명령 exit 0, 6분 25초. 77/77 통과(LanguageProvider 7, OriginalWork 6, Controller 30, Ownership 34), failures/errors/skipped 모두 0. `compileTestKotlin` 실제 실행 성공, 운영 컴파일 UP-TO-DATE. 부모가 네 XML 헤더를 직접 확인했다. 보고서: `build/reports/tests/test/index.html`, XML: `build/test-results/test/`.
- 확장 회귀: 아래 명령은 `:test` 진입 후 600초 제한 초과. 최종 종료 코드·건수·새 XML이 없어 통과/실패를 판정하지 않는다. 컴파일은 UP-TO-DATE이며 새 assertion 실패는 수집되지 않았다. 전체 테스트는 미실행.
```bash
./gradlew test --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' --tests '*LanguageProviderPropertiesTest' --tests '*TranslationCoordinatorTest' --tests '*LanguageDetectionCacheServiceTest' --tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.*' --console=plain
```
- 소유 검증 자원: 재현·검증 자식의 전용 임시 디렉터리 삭제 영수증 확인. 작업 시작 전부터 있던 사용자 worker/daemon은 변경하지 않았다. 부모 초기 임시 루트는 정리 확인 시 이미 존재하지 않았다.
- 최종 독립 리뷰: APPROVE, 차단 사유 없음. 네 테스트의 전체 변경 hunk를 운영 계약과 대조하여 assertion 보존과 실제 invalidation spy 동작을 확인했다. 기존 staged 변경은 보존했고, 운영 코드 변경 및 테스트 삭제/skip은 없다.
- 임시 작업 노트 삭제 완료. 추가 운영·테스트 코드 변경 없이 종료한다. P1-T1은 완료이고 확장 회귀 통과 체크는 미확인 상태로 남긴다. 전체 검증은 사용자가 `./gradlew test`로 수행한다.
## 재개 검증 (2026-11-18)
- 사용자가 미완료 지점부터 재개를 요청했다. 기존 77개 통과·리뷰 결과를 유지하고 전체 테스트로 남은 확장 회귀와 suite 결과를 함께 확인한다. 이번 실행은 재개 요청에 따른 명시적 검증이며 평상시 자동 전체 실행 규칙을 변경하지 않는다.
- 추가 코드 변경 없이 `./gradlew --no-daemon test --console=plain`을 한 번 실행한다. 이전의 600초 실행 제한 대신 긴 실행 시간을 허용한다. 실패하면 오류와 실제 종료 상태를 기록하고 운영 로직은 변경하지 않는다.
- [x] 전체 테스트 XML 집계 확인. 최종 원본 종료 코드 소실은 아래 검증 한계로 기록.
- [x] 실행 소유 임시 자원 정리 및 결과 보고.
### 지연 원인 확인 및 사용자 승인 조치
- 전체 실행 약 47분 시점에 `ps`, `jstat -gcutil`, 현재 worker의 `jstack`을 확인했다. 작업 전부터 있던 worker PID 97636은 약 2시간 48분 실행, CPU 1046.6%, Old 99.98%, Full GC 2207회·8588.794초, 총 GC 8652.617초였다. 기존 프로세스가 GC를 반복하며 자원을 점유했다.
- 현재 전체 검증 worker PID 21732는 해당 시점 CPU 141.9%, Old 97.77%, 총 GC 71.327초였다. thread dump는 Spring context 초기화의 클래스 파일 탐색을 실행 중이었다. 전체 지연의 모든 원인을 확정한 것은 아니며 두 프로세스의 자원 경합은 관찰됐다.
- 사용자가 기존 worker 종료를 명시적으로 승인했다. PID 97636에 TERM을 보냈으나 잔존하여 KILL로 종료했다. 이후 `ps`에서 PID 97636 부재와 현재 검증 PID 21732 생존을 확인했다. IDE와 현재 검증 프로세스는 유지했다.
- 전체 실행은 3,600,000ms 제한으로 중단됐다. Gradle 자체 종료 코드와 신규 XML은 없으므로 suite 결과는 미확정이다. 실행 소유 PID 21675/21732는 정리됐고 전용 임시 루트 `verify-suite.USElvm`도 삭제 확인했다. 제한 시간만 늘리는 반복 대신 context 캐시와 마지막 실행 위치를 조사한다.
## P2: 승인된 테스트 자원 수명 개선
- 시작 조건: 사용자 `진행한다` 승인. 기존 수정과 사용자 staged 변경은 보존한다.
- 관측: 별도 IDE worker 31728도 Old 99.97%, 약 42초간 Full GC 11회·GC 시간 약 43초 증가. GC 과부하는 재현됐으나 retained object별 기여는 아직 미확인이다.
- 수정 경로: `build.gradle.kts`, `src/test/resources/application.yml`, 조사로 확정한 test datasource override, `src/test/kotlin/kr/co/vividnext/sodalive/support/H2DatabaseLifecycleTest.kt`, `docs/agent-guides/테스트스타일.md`, `docs/agent-guides/실행명령어.md`.
- 범위 밖: 운영 코드 변경, 무관한 테스트 재작성, 기존 staged 파일 수정, commit/push.
### P2-T1: H2 DB 수명 검증과 정리
- [x] 실제 test 설정을 읽는 lifecycle 테스트로 pool 종료 후 DB 잔존 실패 재현.
- [x] H2 마지막 연결 종료 정책을 적용하고, 별도 override의 의존성을 확인해 필요한 것만 정리.
- [x] 같은 lifecycle 테스트 및 직접 관련 연결/동시성 회귀 통과.
### P2-T2: context 상한과 진행 진단
- [x] 테스트 클래스 진행과 제한된 크기의 GC 로그를 확보.
- [x] test worker의 Spring context 캐시 상한 4개를 초기 실험값으로 적용하고 실제 캐시/GC와 실행 결과 확인.
- [x] 필요 시에만 worker 교체 주기를 별도 비교. 근거 없이 기본 적용하지 않는다.
### P2-GATE: 전체 실행과 회귀 방지
- [x] 전체 테스트 실행 결과와 GC 로그 비교. 진행 종료와 통과 여부를 각각 기록.
- [x] 신규 테스트 자원 관리 규칙과 IDE Gradle runner 사용법 문서화.
- [x] 변경 리뷰 및 실행 소유 자원 정리.
- 기존 IDE worker 31728이 실행 중이므로 새로운 테스트 실행 전 사용자에게 종료 승인을 받고 동일 build 출력 경합을 제거한다.
- 사용자가 실행 중인 worker 정리를 승인했다. PID 31728은 종료 전 57분 실행, CPU 1102.3%, Old 99.98%, Full GC 697회·1741.342초였다. TERM 후에도 잔존하여 KILL로 종료했고 `jps -l`에서 테스트 worker 부재를 확인했다. IDE와 Gradle daemon은 유지했다.
- 먼저 진단만 추가: `build.gradle.kts`에서 클래스 시작 로그, PID별 GC 로그(`build/test-gc/test/gc-PID.log`, 파일당 10MB·회전 3개), 명시적 단일 test worker를 설정했다. H2/cache 정책은 아직 변경하지 않았다. `./gradlew --no-daemon help --console=plain` exit 0으로 Gradle Kotlin DSL 확인(20초).
- H2 lifecycle RED: `./gradlew --no-daemon test --tests '*H2DatabaseLifecycleTest' --console=plain`, exit 1, 29초. 풀 종료 후 `IFEXISTS=TRUE` 재접속이 성공하여 `Expected java.sql.SQLException to be thrown, but nothing was thrown.` 실패. 연결 간 marker 데이터 공유와 pool 종료 assertion은 통과했다. 기존 YAML의 DB 잔존을 독립적으로 재현했다.
- 1차 수정: 기본 YAML의 `DB_CLOSE_DELAY=-1`만 `0`으로 변경한다. DB 고유 이름·나머지 옵션·운영 설정은 유지한다. 개별 override 29곳은 별도 단계로 검증한다.
- H2 기본 설정 GREEN: `./gradlew --no-daemon test --tests '*H2DatabaseLifecycleTest' --tests '*AiCharacterAdminAudioContentControllerTest' --tests '*AiCharacterAdminAudioContentOwnershipTest' --console=plain`, exit 0, 약 1분, 65개 통과. context cache는 이 실행까지 기본 32를 유지했다. pool 종료 후 실제 DB 부재와 기존 DB/HTTP 동작을 확인했다.
- 다음 단계: dedicated Hikari pool 소유이며 종료 후 재사용 근거가 없는 개별 테스트 override 29곳의 지연값만 0으로 바꾼다. 별도로 context cache 상한 4를 test worker systemProperty로 설정하고 context 재생성/동시성 회귀 및 전체 실행으로 확인한다. `forkEvery`는 아직 도입하지 않는다.
- 개별 override 29곳은 옵션 값만 변경했고 부모가 전체 diff를 확인했다. 연결 재오픈으로 DB 보존을 요구하는 사용처는 발견되지 않았다. `git diff --check` 통과.
- `./gradlew --no-daemon ktlintKotlinScriptCheck ktlintTestSourceSetCheck --console=plain` exit 0, 54초. 최초 Kotlin DSL closure 줄바꿈 오류 2건은 수정 후 통과했다.
- `./gradlew --no-daemon test --tests '*H2DatabaseLifecycleTest' --tests '*ContentSeriesBannerServiceIntegrationTest' --tests '*ServiceNoticeQueryRepositoryTest' --tests '*ServiceNoticeConcurrencyIntegrationTest' --console=plain` exit 0, 2분 16초. XML 집계 20/20 통과(4+9+6+1), failures/errors/skipped 모두 0. context 매 테스트 재생성, 실제 DB 잠금·동시성, JPA 조회와 DB 수명을 검증했다.
- 승인된 전체 실행: `./gradlew --no-daemon test --console=plain` 진행 중. 결과와 GC 효과는 아직 확정하지 않는다.
- 전체 실행 결과: exit 1, 17분 47.442초, 신규 XML 398개/3,752 tests/6 failures/0 skipped/0 errors. 실패는 OriginalWorkReadRetryTest 6개로 모두 H2 `TRANSLATION_JOB` 또는 `ORIGINAL_WORK_TRANSLATION` 테이블 부재였다. 캐시 축소 시 공유 고정 DB 이름과 context 종료의 충돌 여부를 추적한다.
- 전체 실행 GC(PID 55797): Full GC 2회/3.719242초, GC pause 총 1,359회/24.221353초. 마지막 GC 후 4,085MiB, 최대 GC 후 4,089MiB로 4,096MiB 한도 근접. 완주는 확인했지만 테스트 증가에 대한 여유가 충분하지 않아 worker 주기적 교체 실험이 필요하다. 어떤 객체가 잔존 힙 대부분을 보유하는지는 아직 미확인이다.
- 1차 변경 리뷰 APPROVE. 이후 발견한 suite 실패와 worker 정책 변경은 별도 delta 리뷰 대상으로 남긴다.
### P2-R1: suite에서 드러난 DB 격리와 누적 메모리 보호
- [x] MetadataReadRetryTestSupport의 고정 DB 이름 충돌을 runtime chronology로 확인하고 focused 재현/수정.
- [x] worker 50클래스 단위 교체를 초기 실험값으로 적용하여 JVM별 누적을 제한하고 GC 로그로 효과 확인.
- [x] 전체 재검증, 추가 변경 delta 리뷰와 최종 기록.
- worker 교체는 잔존 객체의 root cause 수정으로 주장하지 않으며, 프로세스 수명에 의한 보호 장치로 구분한다.
- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryContextIsolationTest.kt`에서 실제 원작·커뮤니티 test context를 함께 로드하고, 커뮤니티 context 종료 후 원작 repository의 저장 작업 보존을 검증한다. CreatorCommunityReadRetryTest는 추가 `@Import`와 `@MockBean` 때문에 별도 context를 만들지만 공통 support의 고정 DB 이름을 공유한다.
- 번역 패키지 단독 실행은 1분 3초에 통과했지만, Gradle이 직전 실패 OriginalWork 클래스를 맨 먼저 실행했다. 따라서 이 성공만으로 전체 실행 순서에서 발생한 격리 오류가 해결됐다고 판단하지 않는다. 새 회귀 테스트는 순서에 의존하지 않고 context 충돌을 직접 재현한다.
- 격리 RED: `./gradlew --no-daemon test --tests '*MetadataReadRetryContextIsolationTest' --console=plain`, exit 1, 50초. 커뮤니티 context를 닫은 뒤 원작 repository 조회가 `InvalidDataAccessResourceUsageException → SQLGrammarException → JdbcSQLSyntaxErrorException`로 실패했다. 실제 두 context 종료 경계에서 테이블 손실을 재현했다.
- 최소 수정은 `MetadataReadRetryTestSupport.kt`의 DB 이름에 `\${random.uuid}`를 붙이는 것이다. 기존 상속 context 구성과 transaction/fixture/assertion은 유지한다.
- 격리 GREEN: `./gradlew --no-daemon test --tests '*MetadataReadRetryContextIsolationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' --console=plain`, exit 0, 1분 24초. 재현 테스트와 관련 6개 클래스가 함께 통과했다. 이 실행까지 `forkEvery`를 적용하지 않아 프로세스 분리로 격리 문제를 감추지 않았다.
- `forkEvery = 50`을 이제 적용한다. 한 JVM을 무제한 재사용한 실행의 마지막 GC 후 힙 4,085MiB를 근거로 누적 기간을 제한하는 초기 실험값이다. 전체 실행에서 실제 PID 교체·최대 GC 후 힙·완료 시간을 확인하고 유지 여부를 판단한다.
- 격리 수정 후 lint 재검증은 단독 명령 120초 제한에 걸렸다. `jps -l`에서 소유 프로세스가 남지 않았음을 확인했다. 다음 단일 명령에서 lint와 전체 suite를 함께 검증한다: `./gradlew --no-daemon ktlintKotlinScriptCheck ktlintTestSourceSetCheck test --console=plain`.
### 최종 산출물 확인
- 최종 명령의 background session 결과가 연결 복구 후 사라져 원본 종료 코드와 전체 wall-clock 시간은 복구하지 못했다. 이미 완료된 테스트를 다시 실행하지 않고 남아 있는 HTML/XML/GC 산출물을 직접 대조했다.
- `build/reports/tests/test/index.html`: 3,753 tests, 0 failures, 0 ignored, 100% successful. XML 399개 독립 집계도 3,753 tests/0 failures/0 errors/0 skipped. 기존 실패 OriginalWork 6개와 새 DB 수명·context 격리 테스트 모두 전체 실행에서 통과했다.
- HTML의 `2m41.62s`는 테스트 duration 합계이며 context 초기화 등을 포함한 전체 명령 시간으로 보고하지 않는다.
- 최종 Kotlin script/test source lint 보고서 둘 다 위반 항목 0개. 최종 command exit 원본은 없으며, 이전 단계의 lint exit 0 기록과 구분한다. `git diff --check`도 통과했다.
- 최종 worker PID: 62402, 62915, 63240, 63535, 63748, 63967, 64349, 64724, 64965, 65131, 65315, 65472, 65570. 13개 GC 로그 모두 `heap,exit`가 있고 Full GC 0회다.
- PID별 최대 GC 후 힙(MiB): 1130, 886, 1257, 722, 861, 1392, 1464, 1112, 540, 630, 730, 379, 720. 전체 최대 1,464MiB로 교체 전 실행의 4,089MiB보다 낮다. heap 한도 4,096MiB는 증가시키지 않았다. GC 전후 힙 값이 있는 pause 행 합계는 18.963초이며, 이 값은 heap 전후 값 없는 pause를 포함한 전체 GC 시간과 구분한다.
- worker 50클래스 교체는 관측된 누적을 제한하는 보호 장치로 유지한다. 모든 향후 단일 테스트의 메모리/무한 대기까지 보장하거나, 잔존 객체의 근본 원인이 모두 밝혀졌다고 주장하지 않는다.
- 현재 `jps -l`에 테스트 worker가 없고 작업용 승인 temp parent 디렉터리는 비어 있다. 작업 노트와 소유 temp root는 삭제했다. XML/HTML과 GC 로그는 검증 근거로 build 아래 보존한다.
- 최종 delta 리뷰 재확인: APPROVE, 차단 사유 없음. UUID DB 격리, 실제 두 context 생성·종료 회귀와 finally 정리, worker 50클래스 교체와 캐시 4개 정책을 확인했다. 고정 DB RED/UUID GREEN을 fork 도입 전에 증명한 점을 확인했다. 최종 suite 및 GC 결과와 함께 완료 처리하며 추가 테스트 재실행은 하지 않는다.
- 운영 코드 변경, 테스트 삭제/skip/검증 완화, commit/push는 없다. 기존 사용자 staged 변경은 보존했다. Kotlin LSP는 기존 미설치 상태여서 사용하지 않았으며 실제 Gradle 테스트 컴파일·실행과 lint 산출물로 검증했다.
## P3: 승인된 SQL 출력 및 context 재사용 최적화 (2026-11-19)
- 관측 기준: 최종 전체 worker 구간 1,399.703초, Spring 시작 182회. 중복 제거한 실제 Starting→Started 구간 합계 1,158.593초. stdout 227,792,396 bytes 중 SQL 블록 추정 179,790,139 bytes. 세 클래스 추가 초기화 14회/81.541초는 절감 후보이며 확정 절감량이 아니다.
- 수정 경로: `src/test/resources/application.yml`, `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/all/adapter/in/web/MainContentAllEndToEndTest.kt`, `src/test/kotlin/kr/co/vividnext/sodalive/v2/api/content/overview/adapter/in/web/ContentOverviewEndToEndTest.kt`, `src/test/kotlin/kr/co/vividnext/sodalive/content/series/main/banner/ContentSeriesBannerServiceIntegrationTest.kt`.
- 범위 밖: 운영 코드, 기존 assertion 삭제/완화, 테스트 전체 Transactional 적용, 캐시/worker/heap 조정, 기존 사용자 staged 변경, commit/push.
### P3-T1: SQL 출력 비교
- [x] 변경 전 동일 focused 4클래스 실행으로 GREEN baseline과 시간/stdout/context 횟수 기록.
- [x] SQL 출력과 포맷만 끈 뒤 동일 명령으로 통과와 실제 출력 감소 확인.
### P3-T2: context 재사용과 상태 정리
- [x] 세 클래스의 DB FK/직접·간접 side effect를 확인한다.
- [x] 메서드별 context 재생성을 해당 클래스의 fixture 정리로 바꾼다. HTTP/서비스 호출의 트랜잭션 경계와 OSIV off는 그대로 둔다.
- [x] 같은 focused 실행으로 25개 기존 테스트 통과, 시작 횟수 감소, 누적 데이터 없음과 성능 비교를 확인한다.
- [x] 정리 실패가 기존 assertion에서 드러나는지 검토하고 관련 회귀·lint·단일 게이트 리뷰를 수행한다.
### 검증 명령
```bash
./gradlew --no-daemon test --tests '*MainContentAllEndToEndTest' --tests '*ContentOverviewEndToEndTest' --tests '*ContentSeriesBannerServiceIntegrationTest' --tests '*AdminTranslationSelectionContentsHttpIntegrationTest' --console=plain
```
- SQL 집중 클래스는 설정 영향 측정 대상으로만 실행하며 소스는 수정하지 않는다.
- 전체 테스트는 이번 최적화의 자동 검증으로 반복하지 않는다. 직접 영향 기능별 검증을 수행하고 전체 재실행 여부는 최종 보고에 구분한다.
- [x] 비교 기록과 소유 임시 자원 정리 완료.
### P3 측정 기록
- 변경 전 baseline: 위 focused 명령 exit 0, shell wall 526초(Gradle 8분 45초), 25 tests/0 failures. stdout 104,015,806 bytes, `Hibernate:` 140,318회, Spring 시작 18회/시작 로그 시간 합계 376.851초, testcase 시간 합계 66.206초.
- SQL-only 변경은 공통 YAML의 `hibernate.show_sql`, `hibernate.format_sql` 두 값을 false로 바꾼다. 테스트 소스와 worker/cache 설정은 이 단계에서 변경하지 않는다. 다음 실행에서 실제 SQL 출력이 사라졌는지 확인한다.
- SQL-only 결과: 동일 명령 exit 0, shell wall 373초(Gradle 6분 12초), 25/25 통과. stdout 4,655,102 bytes, `Hibernate:` 0회, Spring 시작 18회/288.724초, testcase 합계 28.514초. 출력 감소를 실제로 확인했다. 시간은 같은 환경 연속 실행의 단일 관측이며 캐시/부하 변동을 배제한 보장값으로 해석하지 않는다.
- context 변경: 세 클래스의 method-level DirtiesContext를 제거하고 AfterEach에서 각 전용 DB의 fixture 테이블만 FK 자식→부모 순서로 삭제한다. `series_published_days_of_week`는 series보다 먼저 제거한다. overview 응답에 items 정확히 1개 assertion을 추가해 이전 fixture 노출도 감지한다. 기존 HTTP/서비스 호출은 테스트 transaction 밖에 유지한다.
- 첫 reuse 실행 exit 1, 227초, overview 6개 실패. 인증 조회의 `MemberContentPreferenceService.resolveForQuery/getStoredPreference`가 기본 preference를 저장하는 실제 부작용을 정리 목록에서 놓쳤다. `member_content_preference.member_id → member.id` FK 위반으로 정리 transaction이 rollback됐고 새 items=1 assertion이 누적된 3/5개 항목을 검출했다. 해당 테이블을 member보다 먼저 정리하도록 보완한다. 기존 조회/OSIV/트랜잭션 동작은 바꾸지 않는다.
- 보완 후 reuse 결과: 같은 focused 명령 exit 0, shell wall 282초(Gradle 4분 42초), 25/25 통과. stdout 872,482 bytes, `Hibernate:` 0회, Spring 시작 4회/168.083초, testcase 합계 28.979초. 대상 세 클래스가 각각 한 번만 시작했다.
- baseline/SQL-only는 worker PID 95648/97025 한 개씩, 최종 reuse는 98759/98894/99190/99357 네 개였다. CLI와 fork/cache/heap 설정은 동일하지만 Gradle의 직전 실패 우선 실행과 class 배치가 달라 단일 wall-time 차이를 통제된 인과 추정으로 주장하지 않는다. 출력 제거와 14회 context 재생성 제거는 로그로 직접 확인했다.
- 추가 검증: owned temp init script에서 JUnit MethodOrderer.Random 및 seed 20261119를 적용해 세 클래스의 메서드 순서를 변경한다. committed fixture cleanup이 순서 독립성을 유지하는지 확인하며 script는 종료 시 제거한다.
- 순서 변경·lint 실행: `./gradlew --no-daemon -I /var/folders/yh/8xsbvpsj5wg2qnxzxdp11_gm0000gn/T/opencode/test-speed.slsAQM/random-method-order.gradle ktlintKotlinScriptCheck ktlintTestSourceSetCheck test --tests '*MainContentAllEndToEndTest' --tests '*ContentOverviewEndToEndTest' --tests '*ContentSeriesBannerServiceIntegrationTest' --console=plain`, exit 0, 4분 44초. XML 3개/17 tests/0 failures/0 errors/0 skipped. 순서 변경과 병행한 lint 실행은 성능 비교 표본으로 사용하지 않는다. 해당 임시 script는 검증 후 제거했다.
- 독립 P3 리뷰 APPROVE: FK 삭제 순서, 간접 생성 preference 정리, 전용 datasource, 기존 statistics/HTTP/commit/OSIV 경계 보존 확인. 정리 실패 때 기존/추가 assertion이 누적 데이터를 검출한 실행 근거도 유지했다.
- P3 후 전체 테스트는 재실행하지 않았다. 앞선 P2의 3,753개 통과와 현재 focused 25개/순서 변경 17개를 구분한다. 사용자 전체 검증 명령: `./gradlew test`.
- 최종 `jps -l`에 테스트 worker가 없음을 확인했다. 임시 init script·노트·owned root를 정리하고 측정값은 이 문서에 보존한다. 코드·assertion 삭제/skip, 운영 코드 변경, commit/push는 없다.
| P3 단계 | shell wall | tests | stdout bytes | Hibernate 표식 | Spring 시작 |
|---|---:|---:|---:|---:|---:|
| 변경 전 | 526초 | 25 PASS | 104,015,806 | 140,318 | 18 |
| SQL 출력 off | 373초 | 25 PASS | 4,655,102 | 0 | 18 |
| context 재사용·fixture 정리 | 282초 | 25 PASS | 872,482 | 0 | 4 |
동일 명령의 관측 결과로 244초 단축됐지만, 단일 연속 실행과 worker 배치 차이가 있어 전체 suite 단축률이나 동일 환경 반복 실행의 보장값으로 확대하지 않는다.
## P4: 승인된 실행 시 테스트 힙 자동 산정
- 시작 조건: 사용자 적용 승인. 기존 변경과 staged 사용자 파일은 보존한다.
- OS 관측: 실제 Liberica17 probe에서 total 34,359,738,368 bytes, free 1,110,003,712 bytes. Darwin JDK 구현은 free_count만 사용해 inactive/speculative를 가용 추정에 반영하지 않는다. `vm_stat`은 4,096-byte page, free 282,532 pages, inactive 3,161,273 pages, speculative 5,015 pages를 별도로 보고했다.
- [x] OS별 관측 의미와 보수적 예산 계산 정책 확정 및 테스트 가능한 최소 build logic 위치 결정.
- [x] 산정 경계, worker 분배, 잘못된 관측, 부족 예산에 대한 자동 테스트 RED/GREEN.
- [x] Test task 실행 직전 산정과 명시적 maxHeapSize 연결. 실제 worker launch/GC maximum 확인.
- [x] 메모리 부족 거부 경로를 실제 시스템 메모리 압박 없이 검증.
- [x] focused/lint/리뷰, 사용법·한계 문서, 소유 임시 probe와 노트/root 정리.
- 범위 밖: 운영 코드·앱 의존성 변경, 테스트 누락/skip/실패 무시, 전체 suite 자동 반복, 실시간 heap resize, worker 동시성 확대, commit/push.
### P4 확정 설계
- build logic는 Java-only `buildSrc`의 단일 `buildlogic.TestHeapPolicy`와 JUnit 5.8.2 경계 테스트로 분리한다. 애플리케이션 classpath에 넣지 않고 Kotlin DSL 플러그인도 추가하지 않는다. 파일은 `buildSrc/build.gradle.kts`, `buildSrc/src/main/java/buildlogic/TestHeapPolicy.java`, `buildSrc/src/test/java/buildlogic/TestHeapPolicyTest.java`, 루트 `build.gradle.kts`, 실행 가이드와 기존 작업 문서다.
- macOS 가용 추정은 `vm_stat`의 `(Pages free + Pages inactive) × page size`다. psutil 7.0.0 `_psosx.py` 원문을 직접 대조해 `avail = inactive + free` 계산이 `free -= speculative`보다 먼저 수행됨을 확인했다. speculative/file-backed를 별도로 더하거나 speculative을 빼지 않는다. 출처: https://github.com/giampaolo/psutil/blob/release-7.0.0/psutil/_psosx.py . 이는 회수 가능량의 추정이지 OS의 할당 보장이 아니다.
- macOS 외에는 JDK 17 OperatingSystemMXBean의 free memory를 보수적 관측값으로 사용한다. 해당 JDK/OS의 container 인식 범위를 넘는 host 추정을 추가하지 않는다. 이 경로의 실제 OS별 실행 검증은 현재 Mac에서 수행할 수 없다는 한계를 기록한다.
- 정책: 가용 추정 A의 절반을 시스템 여유로 남긴다. 유효 worker F=`min(maxParallelForks, maxWorkers)`로 나눈 뒤 worker당 힙 외 1GiB를 제외하고 MiB 단위로 내린다. `heapMiB = floor((floor(floor(A/2)/F) - 1GiB)/1MiB)`. 4,096MiB 미만이면 올려 할당하지 않고 명시적 실패다.
- 메모리 관측은 Test task doFirst에서 한 번 수행한다. 이후 forkEvery로 교체한 worker도 그 task의 동일한 계산값을 사용한다. 구성만 읽는 help 작업은 OS 관측을 실행하지 않는다.
- 경계 검증: 10GiB/worker1과 20GiB/worker2의 정확한 하한, 1 byte 부족, fractional MiB 내림, 유효 worker cap, 4K/16K vm_stat page·누락/중복/음수/overflow, 잘못된 관측·worker 수를 검증한다.
- 실제 부족 예산 검증은 임시 init script로 root test task의 worker 요구량만 64로 높이고 `--max-workers=64` 및 경량 테스트 한 클래스만 선택한다. 32GiB 호스트에서는 64개 worker의 각 4GiB 하한을 충족할 수 없어 시작 전에 실패해야 한다. 실제 메모리를 소모해 시스템 압박을 만드는 방식은 사용하지 않는다. 임시 설정은 검증 후 삭제한다.
### P4 검증 기록
- buildSrc TDD: `./gradlew --no-daemon -p buildSrc test --tests 'buildlogic.TestHeapPolicyTest' --offline`. 최소 구현 RED exit 1(51개 중 50개 assertion 실패), 구현 후 GREEN exit 0/6초/51 tests/0 failures/0 errors/0 skipped. 실제 macOS vm_stat 읽기도 포함한다. XML: `buildSrc/build/test-results/test/TEST-buildlogic.TestHeapPolicyTest.xml`.
- root `./gradlew --no-daemon --offline help --console=plain` exit 0/31초. Test task를 실행하지 않아 메모리 산정 로그와 vm_stat 실행이 없다.
- 최초 실제 worker 검증은 buildSrc 추가로 Kotlin/KAPT task classpath가 바뀌어 재컴파일 중 300초 제한에 걸렸다. worker 시작 전이며, `jps -l`에서 소유 프로세스 잔존이 없음을 확인하고 재개했다. 기존 소스의 컴파일 경고는 수정하거나 숨기지 않았다.
- 재개: `./gradlew --no-daemon --offline test --tests '*H2DatabaseLifecycleTest' --tests '*MetadataReadRetryContextIsolationTest' --info --console=plain`, exit 0/5분 4초. 두 테스트 모두 통과, failures/errors/skipped 0.
- 실제 task-start 로그 `available estimate=13432 MiB, workers=1, maxHeap=5692 MiB`. worker 실행 인자 `-Xmx5692m`와 PID 21951의 `build/test-gc/test/gc-21951.log`의 `Heap Max Capacity: 5692M`가 일치한다. 교체된 worker에도 동일한 상한이 전달됐다. 기본 512MB 또는 이전 고정 4GB로 실행되지 않았다.
- 부족 예산 검증: 임시 init script와 `--max-workers=64`, `--tests '*CodePointTextSplitterTest'`로 실행. 예상대로 exit 1/16초, `Insufficient test memory: availableBytes=15350431744, effectiveWorkers=64, minimumHeapMiB=4096`가 출력됐고 root Test Executor/class 시작 없이 종료했다. 실제 메모리 압박은 만들지 않았다.
- 현재 macOS 실행만 검증했다. 비macOS JDK free-memory 경로 및 vm_stat timeout/interruption 강제 재현은 미검증이다. 전체 애플리케이션 suite는 P4 후 재실행하지 않는다.
- `./gradlew --no-daemon --offline ktlintKotlinScriptCheck --console=plain` exit 0/17초. `git diff --check` 통과. 실제 실행 후 `jps -l`에 소유 테스트 worker가 없음을 확인했다. 기존 Gradle daemon과 IDE는 유지한다.
- 임시 JVM 관측 probe, 부족 예산 init script와 실행 노트를 삭제하고 owned root를 정리한다. 계산식/검증 결과는 이 문서에 남긴다. 앱 코드 및 기존 테스트 파일은 P4에서 수정하지 않았다.
- 최종 독립 리뷰 APPROVE: raw free+inactive 계산, 예산/worker cap/내림/4GiB 하한, parser 오류와 프로세스 정리, doFirst 연결 및 별도 buildSrc 테스트 범위를 확인했다. 비macOS와 강제 timeout/interruption은 미검증으로 유지한다.
- 소유 임시 root 삭제와 부재 확인 완료. 추가 재검증 없이 종료하며 commit/push는 수행하지 않았다.
## P5: 고정 힙 하한·예약량 제거
- 시작 조건: 사용자 승인과 Jenkins 오류 `availableBytes=2460004352, effectiveWorkers=1, minimumHeapMiB=4096`.
- 대상 파일: `buildSrc/src/main/java/buildlogic/TestHeapPolicy.java`, `buildSrc/src/test/java/buildlogic/TestHeapPolicyTest.java`, 루트 `build.gradle.kts` 로그, 실행 가이드와 기존 문서.
- 정책 변경: F=`min(maxParallelForks,maxWorkers)`, P=`floor(floor(A/2)/F)`, native reserve=`ceil(P/4)`, heapMiB=`floor((P-native reserve)/1MiB)`. 고정 1GiB 차감과 4GiB 정책 하한을 제거한다. 양수 입력·overflow 안전성은 유지한다.
- 기술 한계 관측: 로컬 Java17에서 `java -Xmx2m -version`은 성공하고 `java -Xmx1m -version`은 `Too small maximum heap`로 실패했다. 따라서 2MiB 미만만 JVM 실행 불가로 거부하며 상향 보정하지 않는다.
- [x] Jenkins 실제 값, sub-GiB/4GiB 미만 예산, worker 분배, rounding과 JVM 극소 경계의 새 계약을 테스트에서 먼저 RED 확인.
- [x] 비율 계산 구현 후 전체 buildSrc 정책 테스트 GREEN.
- [x] 실제 root worker에 동적 Xmx 전달, script lint·단일 리뷰 확인.
- [x] 현재 정책/미검증 범위 문서와 소유 임시 자원 정리.
- 실제 Jenkins/AWS 실행, 전체 앱 suite, OS 메모리 조회 변경은 범위 밖이다. 이번 회귀는 4GiB 사전 거부를 해결하며 작은 힙에서 모든 테스트가 통과한다고 보장하지 않는다.
- RED: `./gradlew --no-daemon --offline -p buildSrc test --tests 'buildlogic.TestHeapPolicyTest' --console=plain`, exit 1/8초. 58개 중 21개 실패. 실제 Jenkins 값과 1/2/8GiB 입력은 기존 fixed floor 예외를 재현했고, 다른 예산/반올림은 새 비율 계약과 불일치했다. 기존 parser/invalid-input 검사들은 그대로 유지했다.
- 최소 구현: 1GiB 상수를 없애고 `ceil(perWorkerBytes/4)`를 native reserve로 사용한다. 4GiB 정책 하한 대신 JVM 실행 가능 여부만 검사한다. root 로그와 실행 가이드도 비율 정책으로 갱신했다.
- GREEN: 같은 buildSrc focused 명령 exit 0/8초, 58 tests/0 failures/0 errors/0 skipped. Jenkins 제공값 2,460,004,352 bytes가 879MiB를 반환함을 검증했다.
- 실제 root 검증: `./gradlew --no-daemon --offline --max-workers=1 ktlintKotlinScriptCheck test --tests '*CodePointTextSplitterTest' --info --console=plain`, exit 0/9분 11초. buildSrc 변경에 따른 기존 Kotlin/KAPT 재컴파일을 포함했다. CodePointTextSplitterTest 33개 통과와 script lint 성공 확인. 기존 애플리케이션/테스트 컴파일 경고는 숨기거나 변경하지 않았다.
- task 시작 시 관측 13,160MiB, worker 1개, 선택 4,935MiB였고 실제 worker 명령 `-Xmx4935m`과 일치했다. 이 로컬 실행을 Jenkins 노드의 실행 결과로 해석하지 않는다.
- 독립 P5 리뷰 APPROVE. 고정 4GiB·1GiB 값 제거, 비율 예약의 overflow 안전성, 실제 Jenkins 입력과 sub-GiB/rounding 경계, OS reader/기존 보호 설정 유지 및 작은 힙의 한계를 확인했다.
- `git diff --check` 통과, 소유 테스트 worker 없음 확인. 실행 노트·owned temp root 삭제 및 부재 확인 후 종료한다. commit/push는 수행하지 않았다.
## P6: buildSrc Kotlin 통일
- 사용자 승인에 따른 언어 전환이며 정책 변경이 아니다. P5의 Java 58개 GREEN을 baseline으로 사용한다.
- 의존 경계: root build.gradle.kts → TestHeapPolicy public static calculateHeapMiB/readAvailableBytes. parser는 buildSrc 테스트에서만 호출한다. 앱 코드 의존은 없다.
- 변경 파일: `buildSrc/build.gradle.kts`, Java helper/test를 각각 `buildSrc/src/main/kotlin/buildlogic/TestHeapPolicy.kt`, `buildSrc/src/test/kotlin/buildlogic/TestHeapPolicyTest.kt`로 이동, 기존 작업 문서와 사용법 필요 부분.
- 플러그인: Gradle 버전에 맞는 `kotlin-dsl`, Java toolchain 17, 기존 JUnit 5.8.2 유지. 앱 Kotlin 1.6.21은 변경하지 않는다. 로컬에 kotlin-dsl 플러그인이 캐시돼 있지 않아 최초 의존성 해석은 네트워크가 필요할 수 있다.
- [x] Kotlin 전환과 Java 중복 제거. 모든 동작·케이스 보존.
- [x] buildSrc clean focused test에서 58/58 통과, Kotlin 소스 lint와 public JVM signature 확인.
- [x] root Gradle에서 helper를 호출하고 선택된 Xmx가 실제 worker에 전달되는지 확인.
- [x] 독립 리뷰, 문서 기록, 소유 임시 자원 정리.
- `javap` baseline: `public static long calculateHeapMiB(long,int,int)`, `public static long readAvailableBytes()`. 기존 parser는 Java package-private이다. Kotlin에서는 module 내부로 한정한다.
- Java baseline XML: 58 tests/0 failures, 정렬한 testcase 이름 JSON의 SHA-256 `6ba55b03a872659fedbca5419274eeaf42b38c2e219cd01fa34725f7b2447642`. 언어 이동 후 case 보존 확인에만 사용하며 구현 의미는 실제 assertion과 리뷰로 대조한다.
- `./gradlew --no-daemon -p buildSrc help --console=plain` exit 0/52초. 새 kotlin-dsl 플러그인 해석과 Java17/JUnit 설정 로딩을 확인했다. 앱 Kotlin 플러그인 버전은 유지했다.
- buildSrc의 새 Kotlin 소스도 검증하도록 루트와 동일한 ktlint 11.5.0 플러그인을 해당 build에 적용한다. 테스트와 정책의 포맷 검사 범위를 빠뜨리지 않으며 앱 의존성은 바꾸지 않는다.
- `./gradlew --no-daemon -p buildSrc clean test --tests 'buildlogic.TestHeapPolicyTest' ktlintCheck --console=plain` exit 0/52초. Kotlin 컴파일 후 58 tests/0 failures/0 errors/0 skipped와 buildSrc의 script/main/test lint 통과. compileJava/compileTestJava NO-SOURCE로 이전 Java 산출물에 의존하지 않음을 확인했다.
- 변환 후 testcase 이름 digest는 baseline과 동일하다. `javap -classpath buildSrc/build/classes/kotlin/main buildlogic.TestHeapPolicy`는 `.kt`에서 생성된 두 public static 메서드를 확인했다. parser는 internal 메서드로 컴파일된다.
- root 연결: `./gradlew --no-daemon --offline --max-workers=1 ktlintKotlinScriptCheck test --tests '*CodePointTextSplitterTest' --info --console=plain`, exit 0/11분 32초. buildSrc classpath 변경에 따른 기존 Kotlin/KAPT 재컴파일을 포함한다. 기존 컴파일 경고는 변경하거나 숨기지 않았다. CodePointTextSplitterTest 33개, root script lint 통과.
- 실제 root task 로그는 가용 추정 12,099MiB/worker1/선택4,537MiB이고 worker 명령에 `-Xmx4537m`이 전달됐다. Java→Kotlin 이동 후에도 기존 public 호출과 실행 시 산정 연결이 작동했다.
- 독립 P6 리뷰 APPROVE: 계산식/OS reader/parser·예외·프로세스 종료와 58개 case 보존, static API 및 buildSrc Kotlin 설정을 확인했다. `git diff --check` 통과, 소유 테스트 worker 없음 확인. 노트와 owned temp root를 제거했다.
- P6에서 전체 앱 테스트나 실제 Jenkins/AWS 실행은 수행하지 않았다. commit/push도 수행하지 않았다. 기존 P5의 비율 정책과 앱 Kotlin 1.6.21은 유지했다.
## 커밋 전 검증 (2026-11-19)
- 사용자 `/commit-with-validation` 요청으로 P5/P6 변경을 커밋한다.
- `./gradlew --no-daemon --offline -p buildSrc test --tests 'buildlogic.TestHeapPolicyTest' --rerun ktlintCheck --console=plain` exit 0/9초. 정책 테스트를 재실행해 XML의 58 tests/0 failures/0 errors/0 skipped를 확인했다. buildSrc lint는 UP-TO-DATE였다.
- 이번 커밋 검증에서 root focused test와 실제 Jenkins/AWS 실행은 반복하지 않았다. 전체 앱 테스트도 미실행이며 사용자 실행 명령은 `./gradlew test`다.
@@ -0,0 +1,51 @@
# 번역 및 관리자 오디오 테스트 수정
- 작성일: 2026-11-18
- 상태: P6 buildSrc Kotlin 통일 완료. 정책 58개/focused 33개/lint/API/리뷰 통과. 실제 Jenkins와 전체 suite는 P6 후 미실행.
- 구현 계획: [plan-task.md](plan-task.md)
## 목표와 범위
운영 로직을 변경하지 않고 사용자가 지정한 네 테스트의 설정·fixture 불일치를 수정한다. 기존 assertion의 의미와 검증 강도를 유지한다. 전체 테스트 통과가 사용자 목표이며, 저장소 실행 규칙에 따라 에이전트는 focused 및 관련 회귀를 검증하고 전체 실행은 사용자에게 안내한다.
## 수용 기준
| ID | 확정 요구사항 | 검증 |
|---|---|---|
| TEST-01 | 기본 AWS 우선과 독립적인 기능 순서, 잘못된 순서 거부를 유지한다. | LanguageProviderSpringConfigurationTest |
| TEST-02 | 현재 FAILED 작업 재개와 다른 언어 작업의 보존을 검증한다. 번역이 없으면 현재 언어 작업을 예약하는 기존 계약을 반영한다. | OriginalWorkReadRetryTest |
| TEST-03 | 관리자 오디오 정상 응답·소유권·인증·입력 검증과 거부 요청의 부작용 없음 검증을 유지한다. | AiCharacterAdminAudioContentControllerTest, AiCharacterAdminAudioContentOwnershipTest |
| TEST-04 | 운영 코드 변경, 테스트 삭제/skip/검증 완화 없이 관련 회귀를 통과한다. | diff 및 focused test 결과 리뷰 |
## 제외
운영 코드와 API 계약 변경, 무관한 리팩터링, 기존 staged 변경 수정, 커밋은 제외한다.
## 추가 승인: 테스트 자원 수명 관리
- 사용자가 공통 테스트 실행 설정·H2 수명 설정·직접 관련 테스트 변경을 승인했다. 운영 코드와 assertion 강도는 유지하고 commit/push는 수행하지 않는다.
- H2의 마지막 연결 종료 시 DB 해제와 열린 연결 간 데이터 공유를 실제 JDBC/connection pool로 검증한다. context별 DB 격리는 유지한다.
- Spring context 캐시 상한을 작은 값부터 비교하고, 진행 위치와 GC 로그를 남겨 조용한 장시간 정지를 진단할 수 있어야 한다.
- 전체 테스트가 정상 종료하여 종료 코드/XML을 생성하고 후반 GC 과부하가 재현되지 않는지 확인한다. 필요 시 worker 교체는 원인 수정과 별도 보호 장치로 평가한다.
- 신규 테스트 작성 규칙에 context 재사용, H2/fixture 수명, 비동기 자원 종료를 기록한다. 테스트 누락/skip/검증 완화로 완료 처리하지 않는다.
## 추가 승인: SQL 출력과 세 클래스 초기화 비용 최적화
- 2026-11-19 사용자 승인: SQL 상세 출력·포맷팅 비활성화와 세 클래스의 메서드별 context 폐기를 명시적 fixture 정리로 대체한다.
- 대상: MainContentAllEndToEndTest, ContentOverviewEndToEndTest, ContentSeriesBannerServiceIntegrationTest. DB/HTTP/commit/OSIV 및 기존 assertion을 유지한다.
- 캐시 4개, worker 50클래스 교체, 동시 worker 1개, heap 4GB는 유지한다. 공통 context 재설계·테스트 순서 강제·운영 코드 변경은 제외한다.
- 동일 focused 실행으로 변경 전, SQL 출력 변경 후, context 재사용 후 결과를 따로 비교한다. 출력 감소와 실제 시간 단축은 구분하며 실측 결과만 보고한다.
## 추가 승인: 실행 시 테스트 힙 자동 산정
- 2026-11-19 사용자가 고정 4GB 대신 시작 시 가용 메모리를 기반으로 테스트 worker 힙을 계산하는 방식을 승인했다.
- Gradle 8.1.1의 기본 512MB 상한으로 돌아가지 않도록 계산한 `maxHeapSize`를 명시적으로 전달한다. 계산은 설정 로딩 때가 아닌 Test task 실행 직전에 수행한다.
- OS의 현재 메모리 관측값에 안전 여유와 JVM 힙 외 메모리 예산을 남기고 동시 worker 수로 나눈다. 기존에 검증한 4GiB를 보수적 실행 하한으로 유지하며, 하한 미달 또는 유효한 관측 불가 시 worker 시작 전에 이유를 알리고 중단한다. 하한은 수학적으로 입증된 최소 필요량이라는 뜻이 아니다.
- macOS JDK의 free-only 값은 전체 가용량이 아니므로 회수 가능한 메모리 추정 규칙을 출처와 함께 명시한다. 실행 도중 가용량 변화에 따른 실시간 heap 재조정이나 무제한 할당은 제외한다.
- 기존 cache 4개, 50클래스 worker 교체, 동시 worker 1개는 유지한다. 운영 코드 변경, commit/push는 제외한다.
## 추가 승인: 고정 하한과 고정 예약량 제거
- Jenkins가 보고한 `availableBytes=2460004352`를 4GiB 하한 때문에 거부한 뒤, 사용자가 하한도 고정하지 말고 현재 관측값으로 결정하도록 승인했다.
- 4GiB 정책 하한과 worker당 고정 1GiB 예약을 제거한다. 전체 관측값의 50%를 worker에 배분하고 그 예산의 25%를 힙 외 용도로 남겨, 나머지 75%를 힙 상한으로 사용한다. worker 수와 MiB 내림을 유지한다.
- 정책상의 최소 힙을 임의로 올려 할당하지 않는다. 현재 JDK가 실행 자체를 거부하는 1MiB 이하만 명시적으로 거부한다. 이는 앱 테스트의 필요 힙을 보장하는 하한이 아니다.
- OS 관측 구현·기존 cache/fork/parallel 설정은 유지한다. Linux MemAvailable/cgroup 관측 변경, 운영 코드·commit·push는 이번 범위에 포함하지 않는다.
## 추가 승인: buildSrc Kotlin 통일
- 사용자가 힙 정책과 테스트를 프로젝트 관례에 맞게 Kotlin으로 통일하도록 승인했다.
- Java helper/test를 Kotlin 소스로 이동하고 중복 Java 파일을 제거한다. 현재 P5 계산식·OS 관측·오류·자원 정리와 58개 테스트 케이스를 보존한다.
- buildSrc에는 Gradle 8.1.1에 맞는 `kotlin-dsl`을 적용하고 Java 17/JUnit 5.8.2를 유지한다. 앱의 Kotlin 1.6.21 버전과 운영 코드, root Test 정책은 변경하지 않는다.
- public static 호출 호환성과 실제 루트 Gradle 연결을 검증한다. commit/push와 전체 앱 suite 자동 실행은 제외한다.
+13
View File
@@ -44,6 +44,19 @@
위 명령은 목적에 맞게 하나를 선택한다. 전체 테스트 확인만 필요하면 `./gradlew test`로 충분하다.
## 테스트 메모리와 진행 진단
- IntelliJ의 `Build, Execution, Deployment > Build Tools > Gradle > Run tests using`을 `Gradle`로 맞추면 CLI와 같은 테스트 JVM 설정을 사용한다. IDE 자체 JUnit runner는 Gradle의 heap/worker 설정을 적용하지 않는다.
- 테스트 JVM heap은 Test task 실행 직전에 가용 메모리로 계산한다. 가용 추정의 50%를 유효 동시 worker 수(`min(maxParallelForks, maxWorkers)`)로 나누고, 그 worker 예산의 25%를 힙 외 용도로 남긴다. 나머지 75%를 MiB 단위로 내려 명시적 `maxHeapSize`로 전달한다. 고정 4GiB 정책 하한이나 고정 1GiB 예약은 사용하지 않는다. 단, JVM 실행 자체가 불가능한 2MiB 미만 결과는 상향 보정하지 않고 명시적으로 거부한다.
- macOS 가용 추정은 `vm_stat`의 `(Pages free + Pages inactive) × page size`이며 speculative/file-backed를 별도로 더하지 않는다. 다른 OS는 JDK의 free-memory 관측값을 보수적으로 사용하므로 회수 가능한 캐시를 충분히 반영하지 못할 수 있다. 가용 추정은 OS의 할당 보장이 아니며 다른 앱의 이후 사용량도 예측하지 못한다.
- 콘솔의 `Test heap:`에서 관측값·유효 worker 수·선택한 상한을 확인한다. task 시작 때 한 번 계산하며 교체된 worker도 동일한 상한을 사용한다. 메모리 부족 오류가 나면 다른 프로그램/중복 테스트를 정리한 뒤 다시 실행한다. 기존 `maxHeapSize`만 지워 Gradle 기본 512MB로 돌아가거나, 비율 옵션만 추가하는 방식은 사용하지 않는다.
- 예를 들어 관측값 2,460,004,352 bytes와 worker 1개는 879MiB 힙을 선택한다. 4GiB 미만이라는 이유만으로 중단하지 않지만, 선택된 예산이 앱 테스트의 실제 메모리 요구량보다 작으면 JVM에서 OOM이 발생할 수 있다. 계산 성공을 전체 테스트 통과 보장으로 해석하지 않는다.
- 동시 worker 1개, Spring context 캐시 최대 4개, 50개 테스트 클래스마다 worker 교체는 유지한다. 클래스 수 기준이므로 단일 클래스의 과도한 사용까지 방지하지는 않는다. Gradle daemon heap과 테스트 worker heap은 별개다. 같은 저장소의 전체 테스트를 IDE와 CLI/에이전트에서 동시에 시작하지 않는다.
- 실행 콘솔의 `Test class:`는 클래스 시작 위치이며 완료 또는 성공 표시가 아니다. 최종 종료 코드와 `build/test-results/test/`의 해당 실행 XML을 함께 확인한다.
- GC 로그는 `build/test-gc/<task 이름>/gc-<PID>.log`에 기록한다. PID별 10MB 파일과 회전 로그 최대 3개를 사용한다. 오래된 실행 로그는 조사 후 정리한다.
- 후반에 진행이 멈추면 해당 worker PID의 `jstat -gcutil <PID>`와 GC 로그를 확인한다. Old 사용률이 높고 Full GC 시간만 증가하는 상태에서는 실행 제한만 늘리지 않는다. 타인이 시작한 worker는 승인 없이 종료하지 않는다.
- 힙 예산 build logic를 변경하면 `./gradlew --no-daemon -p buildSrc test --tests 'buildlogic.TestHeapPolicyTest'`로 산정·파싱 경계를 검증한다. 이 테스트는 애플리케이션의 root `test`와 별도이며, 일반 root 실행에서 buildSrc 컴파일만 됐다고 테스트까지 통과한 것으로 보지 않는다.
- 힙 정책과 테스트는 `buildSrc/src/main/kotlin/buildlogic/TestHeapPolicy.kt`, `buildSrc/src/test/kotlin/buildlogic/TestHeapPolicyTest.kt`에 둔다. buildSrc는 Gradle 버전에 맞는 `kotlin-dsl`과 Java 17 toolchain을 사용하며 앱의 Kotlin 버전과 별도로 관리한다. 해당 Kotlin 소스의 포맷 검사는 `./gradlew --no-daemon -p buildSrc ktlintCheck`로 실행한다.
## AWS 의존성 확인
기존 SDK v1은 유지하고 Comprehend/Translate만 SDK v2 BOM `2.57.11`을 사용한다. 기본 동기 HTTP runtime은 전이 의존성이다.
+8
View File
@@ -19,6 +19,14 @@
- Redis가 필요한 통합 테스트만 `@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])`로 명시적으로 opt-in 한다.
- Redis가 필요 없는 JPA/QueryDSL 슬라이스 테스트는 기존 관례처럼 `@DataJpaTest(properties = ["spring.cache.type=none"])`로 캐시를 끈다.
## 테스트 자원 수명과 context 재사용
- 같은 종류의 통합 테스트는 기존 properties, profile, initializer, bean override 구성을 우선 재사용한다. 불필요한 클래스별 `@MockBean`/`@SpyBean`·설정 차이는 별도 context를 만든다. 격리를 위한 차이는 유지한다.
- Hikari가 관리하는 테스트 H2는 context별 DB 이름을 유지하고 `DB_CLOSE_DELAY=0`을 사용한다. 마지막 연결 종료 뒤에도 DB를 유지해야 하는 테스트는 그 이유와 명시적인 종료 책임을 증명한다. `create-drop`만으로 DB 엔진 종료를 대신하지 않는다.
- 상속한 test support에서 서로 다른 Spring context를 만들 수 있다면 H2 이름에 `${random.uuid}`처럼 context별 고유 값을 사용한다. 고정 이름을 공유하면 한 context의 `create-drop` 종료가 다른 context의 테이블을 삭제할 수 있다.
- 단순 DB fixture 정리에 `@DirtiesContext`를 추가하지 않는다. rollback 범위 밖의 commit·`REQUIRES_NEW`·비동기 데이터는 테스트가 정리하고, context 상태 복구가 불가능한 경우에만 context를 폐기한다.
- 테스트가 만든 executor, client, 임시 서버와 비동기 작업은 실패 경로에서도 정리한다. latch/Future 대기에 제한을 두고, 작업 해제·취소 후 executor 종료 완료를 확인한다.
- 메모리 부족을 테스트 skip, assertion 완화, 무조건적인 heap 증설로 해결하지 않는다. GC 로그와 실제 보유 객체, context 수명부터 확인한다. worker 교체는 별도 보호 장치이며 누적 원인 수정의 대체물이 아니다.
## 저장 시각·응답 왕복 검증 규칙
- DB 재조회 시각과 API 응답을 비교하는 테스트는 OS의 현재 시각만 사용하지 않는다. 기존 시각 주입 seam을 재사용해
나노초 `0`, `123456789`, `999999999`와 `23:59:59` 같은 초/날짜 경계 입력을 고정한다.
@@ -9,15 +9,17 @@ import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.main.tab.GetContentMainTabItem
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.utils.generateFileName
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.toContentSourceSnapshot
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.domain.Pageable
import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import org.springframework.web.multipart.MultipartFile
@Service
@@ -29,10 +31,14 @@ class AdminContentService(
private val contentMainTabRepository: AdminContentMainTabRepository,
private val objectMapper: ObjectMapper,
private val s3Uploader: S3Uploader,
private val applicationEventPublisher: ApplicationEventPublisher,
private val sourceInvalidation: ContentTranslationSourceInvalidationService,
transactionManager: PlatformTransactionManager,
@Value("\${cloud.aws.s3.bucket}")
private val bucket: String
) {
private val uploadTransaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_NOT_SUPPORTED
}
fun getAudioContentList(status: ContentReleaseStatus, pageable: Pageable): GetAdminContentListResponse {
val totalCount = repository.getAudioContentTotalCount(status = status)
val audioContentAndThemeList = repository.getAudioContentList(
@@ -99,25 +105,31 @@ class AdminContentService(
fun updateAudioContent(coverImage: MultipartFile?, requestString: String) {
val requestNode = objectMapper.readTree(requestString)
val request = objectMapper.treeToValue(requestNode, UpdateAdminContentRequest::class.java)
val audioContent = repository.findByIdOrNull(id = request.id)
?: throw SodaException(messageKey = "admin.content.not_found")
val audioContent = repository.findByIdOrNull(request.id) ?: throw SodaException(messageKey = "admin.content.not_found")
if (coverImage != null) {
val uploadedCover = if (coverImage != null) {
val metadata = ObjectMetadata()
metadata.contentLength = coverImage.size
val fileName = generateFileName(prefix = "${request.id}-cover")
val imagePath = s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = bucket,
filePath = "audio_content_cover/${request.id}/$fileName",
metadata = metadata
)
audioContent.coverImage = imagePath
uploadTransaction.execute {
s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = bucket,
filePath = "audio_content_cover/${request.id}/$fileName",
metadata = metadata
)
}
} else if (request.isDefaultCoverImage) {
audioContent.coverImage = "profile/default_profile.png"
"profile/default_profile.png"
} else {
null
}
sourceInvalidation.lock(audioContent)
val before = audioContent.toContentSourceSnapshot()
if (uploadedCover != null) audioContent.coverImage = uploadedCover
if (request.isActive != null) {
if (!request.isActive) {
audioContent.releaseDate = null
@@ -163,15 +175,7 @@ class AdminContentService(
audioContent.settlementRatio = request.settlementRatio
}
if (request.title != null || request.detail != null) {
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = request.id,
targetType = LanguageTranslationTargetType.CONTENT,
waitTransactionCommit = true
)
)
}
sourceInvalidation.invalidateChanged(audioContent, before)
}
fun getContentMainTabList(): List<GetContentMainTabItem> {
@@ -8,7 +8,11 @@ import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryService
import kr.co.vividnext.sodalive.i18n.translation.TranslationReadModelMaterializer
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceField
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.toContentSourceSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceSnapshot
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
@@ -29,7 +33,9 @@ data class AudioContentDetailTranslationResult(
class AudioContentDetailTranslationService(
private val repository: AudioContentRepository,
private val translations: ContentTranslationRepository,
private val detector: LanguageDetectionCacheService,
private val languageService: ContentTranslationLanguageService,
private val sourceInvalidation: ContentTranslationSourceInvalidationService,
private val writer: ContentTranslationWriteService,
private val memories: TranslationMemoryService,
private val materializer: TranslationReadModelMaterializer,
private val scheduler: ResourceTranslationJobScheduler,
@@ -44,34 +50,32 @@ class AudioContentDetailTranslationService(
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun resolve(contentId: Long, targetLanguage: String): AudioContentDetailTranslationResult {
var source = transaction.execute { snapshot(contentId) } ?: return AudioContentDetailTranslationResult(null)
if (source.languageCode.isNullOrBlank()) {
val beforeDetection = source
if (source.sourceLanguage.isNullOrBlank()) {
try {
val detected = detector.detectWithCache(source.query)?.detectedLanguage
?: return AudioContentDetailTranslationResult(source.languageCode, detectionQuery = source.query)
source = transaction.execute {
val content = entityManager.find(AudioContent::class.java, contentId, LockModeType.PESSIMISTIC_WRITE)
?: return@execute null
val current = snapshot(contentId) ?: return@execute null
if (current == beforeDetection) content.languageCode = detected
snapshot(contentId)
} ?: return AudioContentDetailTranslationResult(null)
source = languageService.detectMissing(contentId) ?: return AudioContentDetailTranslationResult(null)
} catch (ex: Exception) {
log.warn("Content detail language detection failed. contentId={}, error={}", contentId, ex.message)
return AudioContentDetailTranslationResult(source.languageCode, detectionQuery = source.query)
return AudioContentDetailTranslationResult(source.sourceLanguage, detectionQuery = source.detectionQuery)
}
}
val language = source.languageCode
if (language.isNullOrBlank()) return AudioContentDetailTranslationResult(language, detectionQuery = source.query)
val target = targetLanguage.lowercase()
val existing = transaction.execute {
val content = writer.lockContent(contentId) ?: return@execute null
sourceInvalidation.invalidateStale(content)
source = content.toContentSourceSnapshot()
translations.findByContentIdAndLocale(contentId, target)?.let {
entityManager.refresh(it, LockModeType.PESSIMISTIC_WRITE)
it.renderedPayload
}
}
val language = source.sourceLanguage
if (language.isNullOrBlank()) return AudioContentDetailTranslationResult(language, detectionQuery = source.detectionQuery)
if (
!TranslationLanguages.isSupported(language) || !TranslationLanguages.isSupported(target) ||
language.lowercase() == target
) {
return AudioContentDetailTranslationResult(language)
}
val existing = transaction.execute { translations.findByContentIdAndLocale(contentId, target)?.renderedPayload }
if (existing != null) {
maintainRetries(contentId, target, scheduleMissing = false)
return result(language, existing)
@@ -79,10 +83,19 @@ class AudioContentDetailTranslationService(
return try {
source.fields.forEach { field ->
memories.ensureMemory(LanguageTranslationTargetType.CONTENT, field.fieldKey, field.sourceText, language, target)
val approved = transaction.execute { writer.hasCurrentApproval(contentId, target, field.fieldKey) } == true
if (!approved) {
memories.ensureMemory(
LanguageTranslationTargetType.CONTENT,
field.fieldKey,
field.sourceText,
language,
target
)
}
}
val payload = transaction.execute {
entityManager.find(AudioContent::class.java, contentId, LockModeType.PESSIMISTIC_WRITE)
writer.lockContent(contentId)
check(snapshot(contentId) == source) { "content translation source changed" }
check(materializer.materialize(LanguageTranslationTargetType.CONTENT, contentId, target)) {
"content translation is incomplete"
@@ -125,20 +138,6 @@ class AudioContentDetailTranslationService(
TranslatedContent(payload.title, payload.detail, payload.tags)
)
private fun snapshot(contentId: Long): DetailSource? {
val content = repository.findById(contentId).orElse(null) ?: return null
val tags = content.audioContentHashTags.filter { it.isActive }.mapNotNull { it.hashTag?.tag }
return DetailSource(
content.languageCode,
listOf(
TranslationSourceField("title", content.title),
TranslationSourceField("detail", content.detail),
TranslationSourceField("tags", tags.joinToString(","))
),
listOf(content.title.trim(), content.detail.trim(), tags.joinToString(" ").trim())
.filter { it.isNotBlank() }.joinToString(" ")
)
}
private data class DetailSource(val languageCode: String?, val fields: List<TranslationSourceField>, val query: String)
private fun snapshot(contentId: Long): ContentSourceSnapshot? =
repository.findById(contentId).orElse(null)?.toContentSourceSnapshot()
}
@@ -38,6 +38,8 @@ import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.utils.generateFileName
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.toContentSourceSnapshot
import kr.co.vividnext.sodalive.v2.creatorname.application.CreatorLocalizedNameService
import kr.co.vividnext.sodalive.v2.home.following.application.HomeFollowingNewsPublishService
import kr.co.vividnext.sodalive.v2.recommendation.application.CreatorContentViewHistoryService
@@ -97,6 +99,7 @@ class AudioContentService(
private val homeFollowingNewsPublishService: HomeFollowingNewsPublishService,
private val memberContentPreferenceService: MemberContentPreferenceService,
private val subtitleJobService: SubtitleJobService,
private val sourceInvalidation: ContentTranslationSourceInvalidationService,
transactionManager: PlatformTransactionManager,
@Value("\${cloud.aws.s3.content-bucket}")
@@ -112,6 +115,9 @@ class AudioContentService(
private val registrationTransaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
private val uploadTransaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_NOT_SUPPORTED
}
@Transactional
fun audioContentLike(request: PutAudioContentLikeRequest, member: Member): PutAudioContentLikeResponse {
@@ -145,13 +151,7 @@ class AudioContentService(
val audioContent = repository.findByIdAndCreatorId(request.contentId, member.id!!)
?: throw SodaException(messageKey = "content.error.invalid_content_retry")
if (request.title != null) audioContent.title = request.title
if (request.detail != null) audioContent.detail = request.detail
if (request.isPointAvailable != null) audioContent.isPointAvailable = request.isPointAvailable
audioContent.isCommentAvailable = request.isCommentAvailable
audioContent.isAdult = request.isAdult
if (coverImage != null) {
val uploadedCover = if (coverImage != null) {
val metadata = ObjectMetadata()
metadata.contentLength = coverImage.size
@@ -159,16 +159,28 @@ class AudioContentService(
val coverImageFileName = generateFileName(prefix = "${audioContent.id}-cover")
// 커버 이미지 업로드
val coverImagePath = s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = coverImageBucket,
filePath = "audio_content_cover/${audioContent.id}/$coverImageFileName",
metadata = metadata
)
audioContent.coverImage = coverImagePath
uploadTransaction.execute {
s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = coverImageBucket,
filePath = "audio_content_cover/${audioContent.id}/$coverImageFileName",
metadata = metadata
)
}
} else {
null
}
sourceInvalidation.lock(audioContent)
if (audioContent.member?.id != member.id) throw SodaException(messageKey = "content.error.invalid_content_retry")
val before = audioContent.toContentSourceSnapshot()
if (request.title != null) audioContent.title = request.title
if (request.detail != null) audioContent.detail = request.detail
if (request.isPointAvailable != null) audioContent.isPointAvailable = request.isPointAvailable
audioContent.isCommentAvailable = request.isCommentAvailable
audioContent.isAdult = request.isAdult
if (uploadedCover != null) audioContent.coverImage = uploadedCover
if (!request.tags.isNullOrBlank()) {
val normalizedTags = request.tags
.replace("#", " #")
@@ -201,22 +213,18 @@ class AudioContentService(
audioContentHashTag
}
audioContent.audioContentHashTags.addAll(newAudioContentHashTagList)
val added = newAudioContentHashTagList.filter { it !in audioContent.audioContentHashTags }
audioContent.audioContentHashTags.addAll(added)
}
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = request.contentId,
targetType = LanguageTranslationTargetType.CONTENT,
waitTransactionCommit = true
)
)
sourceInvalidation.invalidateChanged(audioContent, before)
}
@Transactional
fun deleteAudioContent(audioContentId: Long, member: Member) {
val audioContent = repository.findByIdAndCreatorId(audioContentId, member.id!!)
?: throw SodaException(messageKey = "content.error.invalid_content_retry")
sourceInvalidation.lock(audioContent)
if (audioContent.member?.id != member.id) throw SodaException(messageKey = "content.error.invalid_content_retry")
val pinContent = pinContentRepository.findByContentIdAndMemberId(
contentId = audioContentId,
@@ -412,13 +420,8 @@ class AudioContentService(
registrationTransaction.executeWithoutResult {
// 언어 코드가 지정되지 않은 경우, 파파고 언어 감지 API를 통해 비동기로 언어를 식별한다.
if (audioContent.languageCode.isNullOrBlank()) {
val papagoQuery = listOf(
request.title.trim(),
request.detail.trim(),
request.tags.trim()
)
.filter { it.isNotBlank() }
.joinToString(" ")
val papagoQuery = repository.findByIdOrNull(requireNotNull(audioContent.id))
?.toContentSourceSnapshot()?.detectionQuery ?: return@executeWithoutResult
applicationEventPublisher.publishEvent(
LanguageDetectEvent(
@@ -505,6 +508,7 @@ class AudioContentService(
val audioContent = repository.findByIdOrNull(contentId)
?: throw SodaException(messageKey = "common.error.invalid_request")
sourceInvalidation.lock(audioContent)
audioContent.content = content
audioContent.duration = duration
@@ -556,7 +560,14 @@ class AudioContentService(
fun releaseContent() {
val notReleasedAudioContent = repository.getNotReleaseContent()
for (audioContent in notReleasedAudioContent) {
for (audioContent in notReleasedAudioContent.sortedBy { it.id }) {
sourceInvalidation.lock(audioContent)
if (
audioContent.isActive || audioContent.releaseDate == null || audioContent.releaseDate!! > LocalDateTime.now() ||
audioContent.duration == null
) {
continue
}
audioContent.isActive = true
applicationEventPublisher.publishEvent(
@@ -11,17 +11,21 @@ import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommuni
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import org.slf4j.LoggerFactory
import org.springframework.data.repository.findByIdOrNull
import org.springframework.scheduling.annotation.Async
import org.springframework.stereotype.Component
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.event.TransactionPhase
import org.springframework.transaction.event.TransactionalEventListener
import org.springframework.transaction.support.TransactionSynchronization
import org.springframework.transaction.support.TransactionSynchronizationManager
import org.springframework.transaction.support.TransactionTemplate
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@@ -51,7 +55,6 @@ class LanguageDetectEvent(
@Component
class LanguageDetectListener(
private val audioContentRepository: AudioContentRepository,
private val audioContentCommentRepository: AudioContentCommentRepository,
private val chatCharacterRepository: ChatCharacterRepository,
private val characterCommentRepository: CharacterCommentRepository,
@@ -63,30 +66,41 @@ class LanguageDetectListener(
private val languageDetectionCacheService: LanguageDetectionCacheService,
private val creatorCommunityTranslationService: CreatorCommunityTranslationService,
private val entityManager: EntityManager,
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler,
private val contentLanguageService: ContentTranslationLanguageService,
transactionManager: PlatformTransactionManager
) {
private val log = LoggerFactory.getLogger(LanguageDetectListener::class.java)
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Async
@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun detectLanguage(event: LanguageDetectEvent) {
if (event.query.isBlank()) {
log.debug("[LanguageDetect] query is blank. Skip language detection. targetId={}", event.id)
return
}
when (event.targetType) {
LanguageDetectTargetType.CONTENT -> handleContentLanguageDetect(event)
LanguageDetectTargetType.COMMENT -> handleCommentLanguageDetect(event)
LanguageDetectTargetType.CHARACTER -> handleCharacterLanguageDetect(event)
LanguageDetectTargetType.CHARACTER_COMMENT -> handleCharacterCommentLanguageDetect(event)
LanguageDetectTargetType.CREATOR_CHEERS -> handleCreatorCheersLanguageDetect(event)
LanguageDetectTargetType.SERIES -> handleSeriesLanguageDetect(event)
LanguageDetectTargetType.ORIGINAL_WORK -> handleOriginalWorkLanguageDetect(event)
LanguageDetectTargetType.CREATOR_CONTENT_CATEGORY -> handleCreatorContentCategoryLanguageDetect(event)
LanguageDetectTargetType.CREATOR_COMMUNITY -> handleCreatorCommunityLanguageDetect(event)
if (event.targetType == LanguageDetectTargetType.CONTENT) {
contentLanguageService.detectMissing(event.id, event.query)
return
}
transaction.executeWithoutResult {
when (event.targetType) {
LanguageDetectTargetType.CONTENT -> error("CONTENT detection uses the source guard")
LanguageDetectTargetType.COMMENT -> handleCommentLanguageDetect(event)
LanguageDetectTargetType.CHARACTER -> handleCharacterLanguageDetect(event)
LanguageDetectTargetType.CHARACTER_COMMENT -> handleCharacterCommentLanguageDetect(event)
LanguageDetectTargetType.CREATOR_CHEERS -> handleCreatorCheersLanguageDetect(event)
LanguageDetectTargetType.SERIES -> handleSeriesLanguageDetect(event)
LanguageDetectTargetType.ORIGINAL_WORK -> handleOriginalWorkLanguageDetect(event)
LanguageDetectTargetType.CREATOR_CONTENT_CATEGORY -> handleCreatorContentCategoryLanguageDetect(event)
LanguageDetectTargetType.CREATOR_COMMUNITY -> handleCreatorCommunityLanguageDetect(event)
}
}
}
@@ -126,44 +140,6 @@ class LanguageDetectListener(
)
}
private fun handleContentLanguageDetect(event: LanguageDetectEvent) {
val contentId = event.id
val audioContent = audioContentRepository.findById(contentId).orElse(null)
if (audioContent == null) {
log.warn("[LanguageDetect] AudioContent not found. contentId={}", contentId)
return
}
// 이미 언어 코드가 설정된 경우 호출하지 않음
if (!audioContent.languageCode.isNullOrBlank()) {
log.debug(
"[LanguageDetect] languageCode already set. Skip language detection. contentId={}, languageCode={}",
contentId,
audioContent.languageCode
)
return
}
val langCode = detectLanguageCode(event) ?: return
audioContent.languageCode = langCode
// REQUIRES_NEW 트랜잭션 내에서 변경 내용을 저장한다.
audioContentRepository.save(audioContent)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = contentId
)
log.info(
"[LanguageDetect] languageCode updated. contentId={}, langCode={}",
contentId,
langCode
)
}
private fun handleCommentLanguageDetect(event: LanguageDetectEvent) {
val commentId = event.id
@@ -4,29 +4,48 @@ import kr.co.vividnext.sodalive.i18n.translation.DetectedLanguage
import kr.co.vividnext.sodalive.i18n.translation.LanguageDetectionProvider
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderProperties
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslationCallControl
import kr.co.vividnext.sodalive.i18n.translation.translationCallStop
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
@Service
class LanguageDetectionCacheService(
private val languageDetectionResultRepository: LanguageDetectionResultRepository,
providers: List<LanguageDetectionProvider>,
properties: LanguageProviderProperties
properties: LanguageProviderProperties,
transactionManager: PlatformTransactionManager
) {
private val providers = properties.orderedProviders(properties.detectionOrder, providers) { it.providerId }
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional
fun detectWithCache(query: String): DetectedLanguage? {
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun detectWithCache(query: String): DetectedLanguage? = detect(query, null)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun detectWithCache(query: String, authorizeDispatch: () -> Boolean): DetectedLanguage? {
return detect(query, TranslationCallControl(authorizeDispatch))
}
private fun detect(query: String, control: TranslationCallControl?): DetectedLanguage? {
val normalizedQuery = SourceTextNormalizer.normalize(query)
if (normalizedQuery.isBlank()) return null
val sourceHash = SourceTextNormalizer.hash(normalizedQuery)
providers.forEach { provider ->
val cached = languageDetectionResultRepository.findBySourceHashAndProviderAndNormalizationVersion(
sourceHash = sourceHash,
provider = provider.providerId.code,
normalizationVersion = SourceTextNormalizer.NORMALIZATION_VERSION
)
val cached = transaction.execute {
languageDetectionResultRepository.findBySourceHashAndProviderAndNormalizationVersion(
sourceHash = sourceHash,
provider = provider.providerId.code,
normalizationVersion = SourceTextNormalizer.NORMALIZATION_VERSION
)
}
if (cached != null && cached.detectedLanguage.isNotBlank()) {
return DetectedLanguage(cached.detectedLanguage, provider.providerId)
}
@@ -34,26 +53,30 @@ class LanguageDetectionCacheService(
providers.forEach { provider ->
val detectedLanguage = try {
provider.detect(query)
} catch (_: Exception) {
control?.beforeCall()
if (control == null) provider.detect(query) else provider.detect(query, control)
} catch (error: Exception) {
if (error.translationCallStop() != null) return null
null
}?.takeIf { it.isNotBlank() }?.lowercase() ?: return@forEach
languageDetectionResultRepository.insertIfAbsent(
sourceHash = sourceHash,
sourceTextSample = normalizedQuery.take(MAX_SAMPLE_LENGTH),
detectedLanguage = detectedLanguage,
provider = provider.providerId.code,
confidence = null,
normalizationVersion = SourceTextNormalizer.NORMALIZATION_VERSION
)
val winner = requireNotNull(
languageDetectionResultRepository.findDetectedLanguageForUpdate(
val winner = transaction.execute {
languageDetectionResultRepository.insertIfAbsent(
sourceHash = sourceHash,
sourceTextSample = normalizedQuery.take(MAX_SAMPLE_LENGTH),
detectedLanguage = detectedLanguage,
provider = provider.providerId.code,
confidence = null,
normalizationVersion = SourceTextNormalizer.NORMALIZATION_VERSION
)
)
return DetectedLanguage(winner, provider.providerId)
requireNotNull(
languageDetectionResultRepository.findDetectedLanguageForUpdate(
sourceHash = sourceHash,
provider = provider.providerId.code,
normalizationVersion = SourceTextNormalizer.NORMALIZATION_VERSION
)
)
}
return DetectedLanguage(requireNotNull(winner), provider.providerId)
}
return null
}
@@ -9,6 +9,9 @@ import javax.persistence.LockModeType
interface ContentTranslationRepository : JpaRepository<ContentTranslation, Long> {
fun findByContentIdAndLocale(contentId: Long, locale: String): ContentTranslation?
@Lock(LockModeType.PESSIMISTIC_WRITE)
fun findByContentId(contentId: Long): List<ContentTranslation>
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("select t from ContentTranslation t where t.contentId = :contentId and t.locale = :locale")
fun findByContentIdAndLocaleForUpdate(
@@ -10,15 +10,17 @@ import kr.co.vividnext.sodalive.content.ContentPriceChangeLogRepository
import kr.co.vividnext.sodalive.content.hashtag.AudioContentHashTag
import kr.co.vividnext.sodalive.content.hashtag.HashTag
import kr.co.vividnext.sodalive.content.hashtag.HashTagRepository
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.utils.generateFileName
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.toContentSourceSnapshot
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.domain.Pageable
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import org.springframework.web.multipart.MultipartFile
@Service
@@ -30,7 +32,8 @@ class CreatorAdminContentService(
private val objectMapper: ObjectMapper,
private val s3Uploader: S3Uploader,
private val applicationEventPublisher: ApplicationEventPublisher,
private val sourceInvalidation: ContentTranslationSourceInvalidationService,
transactionManager: PlatformTransactionManager,
@Value("\${cloud.aws.s3.bucket}")
private val bucket: String,
@@ -38,6 +41,9 @@ class CreatorAdminContentService(
@Value("\${cloud.aws.cloud-front.host}")
private val coverImageHost: String
) {
private val uploadTransaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_NOT_SUPPORTED
}
fun getAudioContentList(pageable: Pageable, member: Member): GetCreatorAdminContentListResponse {
val totalCount = repository.getAudioContentTotalCount(memberId = member.id!!)
val audioContentAndThemeList = repository.getAudioContentList(
@@ -115,20 +121,28 @@ class CreatorAdminContentService(
val audioContent = repository.getAudioContent(memberId = member.id!!, audioContentId = request.id)
?: throw SodaException(messageKey = "creator.admin.content.invalid_content")
if (coverImage != null) {
val uploadedCover = if (coverImage != null) {
val metadata = ObjectMetadata()
metadata.contentLength = coverImage.size
val fileName = generateFileName()
val imagePath = s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = bucket,
filePath = "audio_content_cover/${request.id}/$fileName",
metadata = metadata
)
audioContent.coverImage = imagePath
uploadTransaction.execute {
s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = bucket,
filePath = "audio_content_cover/${request.id}/$fileName",
metadata = metadata
)
}
} else {
null
}
sourceInvalidation.lock(audioContent)
if (audioContent.member?.id != member.id) throw SodaException(messageKey = "creator.admin.content.invalid_content")
val before = audioContent.toContentSourceSnapshot()
if (uploadedCover != null) audioContent.coverImage = uploadedCover
if (request.isActive != null) {
if (!request.isActive) {
audioContent.releaseDate = null
@@ -198,17 +212,10 @@ class CreatorAdminContentService(
audioContentHashTag
}
audioContent.audioContentHashTags.addAll(newAudioContentHashTagList)
val added = newAudioContentHashTagList.filter { it !in audioContent.audioContentHashTags }
audioContent.audioContentHashTags.addAll(added)
}
if (request.title != null || request.detail != null || !request.tags.isNullOrBlank()) {
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = request.id,
targetType = LanguageTranslationTargetType.CONTENT,
waitTransactionCommit = true
)
)
}
sourceInvalidation.invalidateChanged(audioContent, before)
}
}
@@ -24,6 +24,8 @@ import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import org.springframework.web.multipart.MultipartFile
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Service
@Transactional(readOnly = true)
@@ -32,6 +34,7 @@ class CreatorAdminContentSeriesService(
private val genreRepository: CreatorAdminContentSeriesGenreRepository,
private val hashTagRepository: HashTagRepository,
private val audioContentRepository: AudioContentRepository,
private val entityManager: EntityManager,
private val s3Uploader: S3Uploader,
private val objectMapper: ObjectMapper,
@@ -275,6 +278,8 @@ class CreatorAdminContentSeriesService(
fun addingContentToTheSeries(request: AddingContentToTheSeriesRequest, memberId: Long) {
val series = repository.findByIdAndCreatorId(id = request.seriesId, creatorId = memberId)
?: throw SodaException(messageKey = "creator.admin.series.invalid_access")
entityManager.refresh(series, LockModeType.PESSIMISTIC_WRITE)
if (series.member?.id != memberId) throw SodaException(messageKey = "creator.admin.series.invalid_access")
val seriesContentList = mutableListOf<SeriesContent>()
@@ -299,6 +304,8 @@ class CreatorAdminContentSeriesService(
fun removeContentInTheSeries(request: RemoveContentToTheSeriesRequest, memberId: Long) {
val series = repository.findByIdAndCreatorId(id = request.seriesId, creatorId = memberId)
?: throw SodaException(messageKey = "creator.admin.series.invalid_access")
entityManager.refresh(series, LockModeType.PESSIMISTIC_WRITE)
if (series.member?.id != memberId) throw SodaException(messageKey = "creator.admin.series.invalid_access")
series.contentList.removeIf { it.content!!.id == request.contentId }
}
@@ -40,6 +40,56 @@ class SodaMessageSource {
Lang.EN to "Invalid request.",
Lang.JA to "無効なリクエストです。"
),
"translation.selection.not_found" to mapOf(
Lang.KO to "번역 요청 또는 대상을 찾을 수 없습니다.",
Lang.EN to "Translation request or scope was not found.",
Lang.JA to "翻訳リクエストまたは対象が見つかりません。"
),
"translation.selection.invalid_grouping" to mapOf(
Lang.KO to "제목 그룹의 구성원과 원문 구간을 확인해 주세요.",
Lang.EN to "Check title group members and source ranges.",
Lang.JA to "タイトルグループのメンバーと原文の範囲を確認してください。"
),
"translation.selection.revision_conflict" to mapOf(
Lang.KO to "번역 요청이 변경되었습니다. 최신 상태를 조회해 주세요.",
Lang.EN to "The translation request changed. Reload its current state.",
Lang.JA to "翻訳リクエストが変更されました。最新の状態を取得してください。"
),
"translation.selection.idempotency_conflict" to mapOf(
Lang.KO to "같은 요청 식별자를 다른 내용에 사용할 수 없습니다.",
Lang.EN to "The same request identifier cannot be used with a different body.",
Lang.JA to "同じリクエスト識別子を異なる内容には使用できません。"
),
"translation.selection.closed" to mapOf(
Lang.KO to "이미 종료된 번역 요청입니다.",
Lang.EN to "The translation request is already closed.",
Lang.JA to "翻訳リクエストは既に終了しています。"
),
"translation.selection.not_ready" to mapOf(
Lang.KO to "현재 번역 요청 상태에서는 수행할 수 없습니다.",
Lang.EN to "This operation is unavailable in the current translation request state.",
Lang.JA to "現在の翻訳リクエストの状態では実行できません。"
),
"translation.selection.candidate_not_selectable" to mapOf(
Lang.KO to "선택할 수 없는 번역 후보입니다. 요청과 필드, 언어를 확인해 주세요.",
Lang.EN to "This translation candidate cannot be selected. Check its request, field and language.",
Lang.JA to "選択できない翻訳候補です。リクエスト、フィールド、言語を確認してください。"
),
"translation.selection.incomplete_title_group" to mapOf(
Lang.KO to "공통 제목과 모든 구성원의 개별 구간 후보를 선택해 주세요.",
Lang.EN to "Select the common title and residual choices for every group member.",
Lang.JA to "共通タイトルと全メンバーの個別部分の候補を選択してください。"
),
"translation.selection.source_changed" to mapOf(
Lang.KO to "선택한 필드의 원문이 변경되었습니다. 새 번역 요청을 만들어 주세요.",
Lang.EN to "The selected source field changed. Create a new translation request.",
Lang.JA to "選択したフィールドの原文が変更されました。新しい翻訳リクエストを作成してください。"
),
"translation.selection.membership_changed" to mapOf(
Lang.KO to "시리즈의 활성 구성원이 변경되었습니다. 새 번역 요청을 만들어 주세요.",
Lang.EN to "The active series membership changed. Create a new translation request.",
Lang.JA to "シリーズの有効なメンバーが変更されました。新しい翻訳リクエストを作成してください。"
),
"chat.error.room_not_found" to mapOf(
Lang.KO to "채팅방을 찾을 수 없습니다.",
Lang.EN to "Chat room not found.",
@@ -8,15 +8,24 @@ import software.amazon.awssdk.services.comprehend.model.DetectDominantLanguageRe
class AwsLanguageDetectionProvider(private val client: ComprehendClient) : LanguageDetectionProvider {
override val providerId = LanguageProviderId.AWS
override fun detect(query: String): String? {
override fun detect(query: String): String? = detect(query, null)
override fun detect(query: String, control: TranslationCallControl?): String? {
if (query.isBlank()) return null
return try {
// shortcut: 감지는 앞 100000 UTF-8 바이트만 판정하므로 전체 본문과 결과가 다를 수 있음, 전체 본문 기준 품질이 요구되면 별도 감지 정책 승인 후 업그레이드
val text = takeTextPrefixByCodePoint(query, MAX_REQUEST_TEXT_BYTES, ::utf8CodePointSize)
val request = DetectDominantLanguageRequest.builder().text(text).build()
client.detectDominantLanguage(request).languages().firstOrNull()?.languageCode()?.takeIf { it.isNotBlank() }
} catch (_: Exception) {
val request = DetectDominantLanguageRequest.builder().text(text)
control?.let { call ->
request.overrideConfiguration {
it.putExecutionAttribute(AwsTranslationCallInterceptor.CONTROL, call)
.apiCallTimeout(call.remainingTimeout()).apiCallAttemptTimeout(call.remainingTimeout())
}
}
client.detectDominantLanguage(request.build()).languages().firstOrNull()?.languageCode()?.takeIf { it.isNotBlank() }
} catch (error: Exception) {
error.translationCallStop()?.let { throw it }
null
}
}
@@ -22,11 +22,13 @@ class AwsLanguageProviderConfiguration(
fun comprehendClient(): ComprehendClient = ComprehendClient.builder()
.credentialsProvider(credentialsProvider)
.region(region)
.overrideConfiguration { it.addExecutionInterceptor(AwsTranslationCallInterceptor()) }
.build()
@Bean(destroyMethod = "close")
fun translateClient(): TranslateClient = TranslateClient.builder()
.credentialsProvider(credentialsProvider)
.region(region)
.overrideConfiguration { it.addExecutionInterceptor(AwsTranslationCallInterceptor()) }
.build()
}
@@ -0,0 +1,16 @@
package kr.co.vividnext.sodalive.i18n.translation
import software.amazon.awssdk.core.interceptor.Context
import software.amazon.awssdk.core.interceptor.ExecutionAttribute
import software.amazon.awssdk.core.interceptor.ExecutionAttributes
import software.amazon.awssdk.core.interceptor.ExecutionInterceptor
class AwsTranslationCallInterceptor : ExecutionInterceptor {
override fun beforeTransmission(context: Context.BeforeTransmission, executionAttributes: ExecutionAttributes) {
executionAttributes.getAttribute(CONTROL)?.beforeCall()
}
companion object {
val CONTROL = ExecutionAttribute<TranslationCallControl>("TranslationSelectionCallControl")
}
}
@@ -25,18 +25,25 @@ class AwsTranslationService(private val client: TranslateClient) : TranslationPr
for (text in request.texts) {
val translatedText = StringBuilder()
for (chunk in splitTextByCodePoint(text, MAX_REQUEST_TEXT_BYTES, ::utf8CodePointSize)) {
val sdkRequest = TranslateTextRequest.builder()
val builder = TranslateTextRequest.builder()
.sourceLanguageCode(request.sourceLanguage)
.targetLanguageCode(request.targetLanguage)
.text(chunk)
.build()
val translated = client.translateText(sdkRequest)?.translatedText()
request.callControl?.let { control ->
builder.overrideConfiguration {
it.putExecutionAttribute(AwsTranslationCallInterceptor.CONTROL, control)
.apiCallTimeout(control.remainingTimeout()).apiCallAttemptTimeout(control.remainingTimeout())
}
}
val translated = client.translateText(builder.build())?.translatedText()
if (translated.isNullOrBlank()) return TranslateResult(emptyList())
translatedText.append(translated)
}
translatedTexts.add(translatedText.toString())
}
} catch (_: Exception) {
} catch (error: Exception) {
error.translationCallStop()?.let { throw it }
if (request.callControl != null) throw TranslationProviderFailed()
return TranslateResult(emptyList())
}
return TranslateResult(translatedTexts)
@@ -4,4 +4,9 @@ interface LanguageDetectionProvider {
val providerId: LanguageProviderId
fun detect(query: String): String?
fun detect(query: String, control: TranslationCallControl?): String? {
control?.beforeCall()
return detect(query)
}
}
@@ -0,0 +1,12 @@
package kr.co.vividnext.sodalive.i18n.translation
import org.springframework.http.client.SimpleClientHttpRequestFactory
import org.springframework.web.client.RestTemplate
internal fun papagoAdminTransport(connectTimeoutMs: Int, readTimeoutMs: Int): RestTemplate =
RestTemplate(
SimpleClientHttpRequestFactory().apply {
setConnectTimeout(connectTimeoutMs)
setReadTimeout(readTimeoutMs)
}
)
@@ -13,20 +13,30 @@ class PapagoLanguageDetectionProvider(
@Value("\${cloud.naver.papago-client-id}")
private val papagoClientId: String,
@Value("\${cloud.naver.papago-client-secret}")
private val papagoClientSecret: String
private val papagoClientSecret: String,
@Value("\${sodalive.translation-selection.connect-timeout-ms:3000}")
private val adminConnectTimeoutMs: Int = 3000,
@Value("\${sodalive.translation-selection.read-timeout-ms:15000}")
private val adminReadTimeoutMs: Int = 15000
) : LanguageDetectionProvider {
private val restTemplate = RestTemplate()
private val adminRestTemplate = papagoAdminTransport(adminConnectTimeoutMs, adminReadTimeoutMs)
private val papagoDetectUrl = "https://papago.apigw.ntruss.com/langs/v1/dect"
override val providerId = LanguageProviderId.PAPAGO
override fun detect(query: String): String? {
override fun detect(query: String): String? = detect(query, null)
override fun detect(query: String, control: TranslationCallControl?): String? {
val headers = HttpHeaders().apply {
contentType = MediaType.APPLICATION_FORM_URLENCODED
set("X-NCP-APIGW-API-KEY-ID", papagoClientId)
set("X-NCP-APIGW-API-KEY", papagoClientSecret)
}
val body = LinkedMultiValueMap<String, String>().apply { add("query", query) }
val response = restTemplate.postForEntity(
"https://papago.apigw.ntruss.com/langs/v1/dect",
control?.beforeCall()
val transport = if (control == null) restTemplate else adminRestTemplate
val response = transport.postForEntity(
papagoDetectUrl,
HttpEntity(body, headers),
PapagoLanguageDetectResponse::class.java
)
@@ -14,9 +14,14 @@ class PapagoTranslationService(
private val papagoClientId: String,
@Value("\${cloud.naver.papago-client-secret}")
private val papagoClientSecret: String
private val papagoClientSecret: String,
@Value("\${sodalive.translation-selection.connect-timeout-ms:3000}")
private val adminConnectTimeoutMs: Int = 3000,
@Value("\${sodalive.translation-selection.read-timeout-ms:15000}")
private val adminReadTimeoutMs: Int = 15000
) : TranslationProvider {
private val restTemplate: RestTemplate = RestTemplate()
private val adminRestTemplate = papagoAdminTransport(adminConnectTimeoutMs, adminReadTimeoutMs)
private val papagoTranslateUrl = "https://papago.apigw.ntruss.com/nmt/v1/translation"
@@ -53,7 +58,9 @@ class PapagoTranslationService(
val requestEntity = HttpEntity(body, headers)
val response = restTemplate.postForEntity<PapagoTranslationResponse>(
request.callControl?.beforeCall()
val transport = if (request.callControl == null) restTemplate else adminRestTemplate
val response = transport.postForEntity<PapagoTranslationResponse>(
papagoTranslateUrl,
requestEntity
)
@@ -69,7 +76,9 @@ class PapagoTranslationService(
translatedText.append(translated)
}
translatedTexts.add(translatedText.toString())
} catch (_: Exception) {
} catch (error: Exception) {
error.translationCallStop()?.let { throw it }
if (request.callControl != null) throw TranslationProviderFailed()
return TranslateResult(emptyList())
}
}
@@ -4,7 +4,8 @@ data class TranslateRequest(
val texts: List<String>,
val sourceLanguage: String,
val targetLanguage: String,
val rejectUnchangedAwsResult: Boolean = false
val rejectUnchangedAwsResult: Boolean = false,
val callControl: TranslationCallControl? = null
)
data class TranslateResult(
@@ -0,0 +1,29 @@
package kr.co.vividnext.sodalive.i18n.translation
import java.time.Duration
enum class TranslationCallStopReason { OWNERSHIP_LOST, BUDGET_EXCEEDED }
class TranslationCallStopped(val reason: TranslationCallStopReason) : RuntimeException(reason.name)
class TranslationProviderFailed : RuntimeException("PROVIDER_FAILED")
class TranslationCallControl(
private val authorizeDispatch: () -> Boolean,
budget: Duration = Duration.ofSeconds(15),
private val nanoTime: () -> Long = System::nanoTime
) {
private val deadline = nanoTime() + budget.toNanos()
fun beforeCall() {
remainingTimeout()
if (!authorizeDispatch()) throw TranslationCallStopped(TranslationCallStopReason.OWNERSHIP_LOST)
}
fun remainingTimeout(): Duration {
val remaining = deadline - nanoTime()
if (remaining <= 0) throw TranslationCallStopped(TranslationCallStopReason.BUDGET_EXCEEDED)
return Duration.ofNanos(remaining)
}
}
fun Throwable.translationCallStop(): TranslationCallStopped? =
generateSequence(this) { it.cause }.filterIsInstance<TranslationCallStopped>().firstOrNull()
@@ -21,8 +21,8 @@ enum class TranslationJobStatus {
name = "translation_job",
uniqueConstraints = [
UniqueConstraint(
name = "uk_translation_job_resource_field_target_hash",
columnNames = ["resource_type", "resource_id", "field_key", "target_language", "source_hash"]
name = "uk_translation_job_resource_field_target_hash_language",
columnNames = ["resource_type", "resource_id", "field_key", "target_language", "source_hash", "source_language"]
)
]
)
@@ -1,20 +1,44 @@
package kr.co.vividnext.sodalive.i18n.translation
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Lock
import org.springframework.data.jpa.repository.Modifying
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.query.Param
import java.time.LocalDateTime
import javax.persistence.LockModeType
interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
fun findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
fun findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
resourceType: LanguageTranslationTargetType,
resourceId: Long,
fieldKey: String,
targetLanguage: String,
sourceHash: String
sourceHash: String,
sourceLanguage: String
): TranslationJob?
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query(
"""
select j from TranslationJob j
where j.resourceType = kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType.CONTENT
and j.resourceId = :contentId
and j.fieldKey = :fieldKey
and j.targetLanguage = :targetLanguage
and j.sourceHash = :sourceHash
and j.sourceLanguage = :sourceLanguage
order by j.id
"""
)
fun findContentFieldJobsForUpdate(
@Param("contentId") contentId: Long,
@Param("fieldKey") fieldKey: String,
@Param("targetLanguage") targetLanguage: String,
@Param("sourceHash") sourceHash: String,
@Param("sourceLanguage") sourceLanguage: String
): List<TranslationJob>
fun findByResourceTypeAndResourceIdInAndTargetLanguageAndStatus(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
@@ -61,11 +85,10 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
j.nextRetryAt = :now
where j.id = :jobId
and j.resourceType = kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType.CONTENT
and j.fieldKey = 'tags'
and j.status = kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.COMPLETED
"""
)
fun restartCompletedContentTagsJob(@Param("jobId") jobId: Long, @Param("now") now: LocalDateTime): Int
fun restartCompletedContentFieldJob(@Param("jobId") jobId: Long, @Param("now") now: LocalDateTime): Int
@Query(
"""
@@ -75,6 +98,7 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
and j.fieldKey = :fieldKey
and j.targetLanguage = :targetLanguage
and j.sourceHash = :sourceHash
and j.sourceLanguage = :sourceLanguage
and j.status in (kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.PENDING, kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.RUNNING)
"""
)
@@ -83,7 +107,8 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
@Param("resourceId") resourceId: Long,
@Param("fieldKey") fieldKey: String,
@Param("targetLanguage") targetLanguage: String,
@Param("sourceHash") sourceHash: String
@Param("sourceHash") sourceHash: String,
@Param("sourceLanguage") sourceLanguage: String
): TranslationJob?
@Query(
@@ -91,7 +116,7 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
select j.id
from translation_job j
join (
select resource_type, resource_id, target_language
select resource_type, resource_id, target_language, source_language
from translation_job
where status = 'PENDING'
and next_retry_at <= :now
@@ -100,6 +125,7 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
) g on j.resource_type = g.resource_type
and j.resource_id = g.resource_id
and j.target_language = g.target_language
and j.source_language = g.source_language
where j.status = 'PENDING'
and j.next_retry_at <= :now
order by j.created_at asc
@@ -4,12 +4,15 @@ import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Service
class TranslationJobScheduler(
private val translationJobRepository: TranslationJobRepository,
private val translationCoordinator: TranslationCoordinator,
private val contentTranslationRepository: ContentTranslationRepository
private val contentTranslationRepository: ContentTranslationRepository,
private val entityManager: EntityManager
) {
@Transactional
fun scheduleMissingTranslation(
@@ -18,7 +21,8 @@ class TranslationJobScheduler(
fieldKey: String,
sourceText: String,
sourceLanguage: String,
targetLanguage: String
targetLanguage: String,
refreshCompletedContentField: Boolean = false
) {
val normalizedText = SourceTextNormalizer.normalize(sourceText)
if (normalizedText.isBlank()) return
@@ -30,16 +34,38 @@ class TranslationJobScheduler(
if (normalizedSourceLanguage == normalizedTargetLanguage) return
val sourceHash = SourceTextNormalizer.hash(normalizedText)
val existingJob = translationJobRepository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
resourceType = resourceType,
resourceId = resourceId,
fieldKey = fieldKey,
targetLanguage = normalizedTargetLanguage,
sourceHash = sourceHash
)
val forceContentRefresh = resourceType == LanguageTranslationTargetType.CONTENT && refreshCompletedContentField
val existingJob = if (forceContentRefresh) {
translationJobRepository.findContentFieldJobsForUpdate(
resourceId,
fieldKey,
normalizedTargetLanguage,
sourceHash,
normalizedSourceLanguage
).singleOrNull()?.also { entityManager.refresh(it, LockModeType.PESSIMISTIC_WRITE) }
} else {
translationJobRepository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
resourceType = resourceType,
resourceId = resourceId,
fieldKey = fieldKey,
targetLanguage = normalizedTargetLanguage,
sourceHash = sourceHash,
sourceLanguage = normalizedSourceLanguage
)
}
if (existingJob != null) {
if (existingJob.sourceLanguage != normalizedSourceLanguage) return
if (forceContentRefresh) {
when (existingJob.status) {
TranslationJobStatus.FAILED, TranslationJobStatus.COMPLETED -> {
existingJob.status = TranslationJobStatus.PENDING
existingJob.retryCount = 0
existingJob.lastErrorMessage = null
existingJob.nextRetryAt = LocalDateTime.now()
}
TranslationJobStatus.PENDING, TranslationJobStatus.RUNNING -> Unit
}
return
}
when (existingJob.status) {
TranslationJobStatus.FAILED ->
translationJobRepository.restartFailedJob(requireNotNull(existingJob.id), LocalDateTime.now())
@@ -63,7 +89,7 @@ class TranslationJobScheduler(
)
if (cached != null && cached.translatedText == renderedTags) return
translationJobRepository.restartCompletedContentTagsJob(requireNotNull(existingJob.id), LocalDateTime.now())
translationJobRepository.restartCompletedContentFieldJob(requireNotNull(existingJob.id), LocalDateTime.now())
}
TranslationJobStatus.PENDING, TranslationJobStatus.RUNNING -> Unit
}
@@ -33,31 +33,47 @@ class TranslationJobWorker(
val failedJobs = mutableListOf<Pair<TranslationJob, Exception>>()
jobs.forEach { job ->
try {
translationMemoryService.ensureMemory(
job.resourceType,
job.fieldKey,
job.sourceText,
job.sourceLanguage,
job.targetLanguage
)
if (job.resourceType != LanguageTranslationTargetType.CONTENT || !materializer.hasCurrentContentApproval(job)) {
translationMemoryService.ensureMemory(
job.resourceType,
job.fieldKey,
job.sourceText,
job.sourceLanguage,
job.targetLanguage
)
}
succeededJobs.add(job)
} catch (ex: Exception) {
failedJobs.add(job to ex)
}
}
if (failedJobs.isNotEmpty()) {
if (failedJobs.isNotEmpty() && firstJob.resourceType != LanguageTranslationTargetType.CONTENT) {
succeededJobs.forEach { completeJob(it.id!!) }
failedJobs.forEach { (job, ex) -> failJob(job.id!!, ex) }
return true
}
try {
materializer.materialize(firstJob.resourceType, firstJob.resourceId, firstJob.targetLanguage)
succeededJobs.forEach { completeJob(it.id!!) }
} catch (ex: Exception) {
succeededJobs.forEach { failJob(it.id!!, ex) }
if (succeededJobs.isNotEmpty()) {
try {
transactionTemplate.executeWithoutResult {
val materialized = if (firstJob.resourceType == LanguageTranslationTargetType.CONTENT) {
materializer.materializeContentFields(
firstJob.resourceId,
firstJob.targetLanguage,
succeededJobs.map { it.fieldKey }.toSet()
)
} else {
materializer.materialize(firstJob.resourceType, firstJob.resourceId, firstJob.targetLanguage)
}
check(materialized) { "translation materialization is incomplete" }
succeededJobs.forEach { completeJob(it.id!!) }
}
} catch (ex: Exception) {
succeededJobs.forEach { failJob(it.id!!, ex) }
}
}
failedJobs.forEach { (job, ex) -> failJob(job.id!!, ex) }
return true
}
@@ -6,7 +6,6 @@ import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationR
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslation
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationPayload
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationRepository
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.category.CategoryTranslation
import kr.co.vividnext.sodalive.content.category.CategoryTranslationRepository
import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslation
@@ -16,11 +15,10 @@ import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationPayl
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationRepository
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslation
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslation
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslationRepository
import org.springframework.stereotype.Service
@@ -32,7 +30,6 @@ import javax.persistence.LockModeType
class TranslationReadModelMaterializer(
private val sourceExtractor: TranslationSourceExtractor,
private val translationCoordinator: TranslationCoordinator,
private val contentTranslationRepository: ContentTranslationRepository,
private val aiCharacterTranslationRepository: AiCharacterTranslationRepository,
private val contentThemeTranslationRepository: ContentThemeTranslationRepository,
private val seriesTranslationRepository: SeriesTranslationRepository,
@@ -41,15 +38,32 @@ class TranslationReadModelMaterializer(
private val categoryTranslationRepository: CategoryTranslationRepository,
private val creatorCommunityRepository: CreatorCommunityRepository,
private val creatorCommunityTranslationRepository: CreatorCommunityTranslationRepository,
private val entityManager: EntityManager
private val entityManager: EntityManager,
private val contentWriter: ContentTranslationWriteService
) {
@Transactional
fun hasCurrentContentApproval(job: TranslationJob): Boolean = contentWriter.hasCurrentApproval(
job.resourceId,
job.targetLanguage,
job.fieldKey
)
@Transactional
fun materializeContentFields(resourceId: Long, targetLanguage: String, fieldKeys: Set<String>): Boolean =
contentWriter.materialize(
resourceId,
targetLanguage,
fieldKeys.map { key -> ContentSourceFieldKey.values().single { it.key == key } }.toSet()
)
@Transactional
fun materialize(resourceType: LanguageTranslationTargetType, resourceId: Long, targetLanguage: String): Boolean {
if (resourceType == LanguageTranslationTargetType.CONTENT) return contentWriter.materialize(resourceId, targetLanguage)
val source = sourceExtractor.extract(resourceType, resourceId) ?: return false
val translations = resolveTranslatedFields(source, targetLanguage.lowercase()) ?: return false
when (resourceType) {
LanguageTranslationTargetType.CONTENT -> upsertContent(resourceId, targetLanguage, translations)
LanguageTranslationTargetType.CONTENT -> error("CONTENT uses the locked field writer")
LanguageTranslationTargetType.CHARACTER -> upsertCharacter(resourceId, targetLanguage, translations)
LanguageTranslationTargetType.CONTENT_THEME -> upsertContentTheme(resourceId, targetLanguage, translations)
LanguageTranslationTargetType.SERIES -> upsertSeries(resourceId, targetLanguage, translations)
@@ -76,9 +90,7 @@ class TranslationReadModelMaterializer(
val memory = translationCoordinator.findCached(
sourceHash = SourceTextNormalizer.hash(normalizedText),
sourceLanguage = source.sourceLanguage.lowercase(),
targetLanguage = targetLanguage,
rejectUnchangedAwsResult = source.resourceType == LanguageTranslationTargetType.CONTENT &&
field.fieldKey == "tags"
targetLanguage = targetLanguage
) ?: return null
result[field.fieldKey] = memory.translatedText
@@ -86,22 +98,6 @@ class TranslationReadModelMaterializer(
return result
}
private fun upsertContent(resourceId: Long, targetLanguage: String, translations: Map<String, String>) {
val payload = ContentTranslationPayload(
title = translations["title"].orEmpty(),
detail = translations["detail"].orEmpty(),
tags = translations["tags"].orEmpty()
)
entityManager.find(AudioContent::class.java, resourceId, LockModeType.PESSIMISTIC_WRITE)
val existing = contentTranslationRepository.findByContentIdAndLocaleForUpdate(resourceId, targetLanguage)
if (existing == null) {
contentTranslationRepository.save(ContentTranslation(resourceId, targetLanguage, payload))
} else {
existing.renderedPayload = payload
contentTranslationRepository.save(existing)
}
}
private fun upsertCharacter(resourceId: Long, targetLanguage: String, translations: Map<String, String>) {
val payload = AiCharacterTranslationRenderedPayload(
name = translations["name"].orEmpty(),
@@ -8,6 +8,7 @@ import kr.co.vividnext.sodalive.content.AudioContentRepository
import kr.co.vividnext.sodalive.content.category.CategoryRepository
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository
import kr.co.vividnext.sodalive.v2.contenttranslation.application.toContentSourceSnapshot
import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Component
@@ -50,20 +51,13 @@ class TranslationSourceExtractor(
private fun extractContent(resourceId: Long): TranslationSource? {
val content = audioContentRepository.findByIdOrNull(resourceId) ?: return null
val sourceLanguage = content.languageCode?.takeIf { it.isNotBlank() } ?: return null
val tags = content.audioContentHashTags
.filter { it.isActive }
.mapNotNull { it.hashTag?.tag }
.joinToString(",")
val snapshot = content.toContentSourceSnapshot()
val sourceLanguage = snapshot.sourceLanguage?.takeIf { it.isNotBlank() } ?: return null
return TranslationSource(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = resourceId,
sourceLanguage = sourceLanguage,
fields = listOf(
TranslationSourceField("title", content.title),
TranslationSourceField("detail", content.detail),
TranslationSourceField("tags", tags)
)
fields = snapshot.fields
)
}
@@ -0,0 +1,90 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import kr.co.vividnext.sodalive.common.ApiResponse
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionApplyService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionCandidateQueryService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionContentsService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionGenerationService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionGroupingService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionRequestService
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ApplyTranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.CreateTranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.GenerateTranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ReviewTranslationSelectionGroupingRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.response
import org.springframework.security.access.prepost.PreAuthorize
import org.springframework.security.core.annotation.AuthenticationPrincipal
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.PutMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController
@RestController
@RequestMapping("/admin/audio-content/translation-requests")
@PreAuthorize("hasRole('ADMIN')")
class AdminTranslationSelectionController(
private val requests: TranslationSelectionRequestService,
private val grouping: TranslationSelectionGroupingService,
private val contents: TranslationSelectionContentsService,
private val generation: TranslationSelectionGenerationService,
private val candidates: TranslationSelectionCandidateQueryService,
private val applyService: TranslationSelectionApplyService
) {
@PostMapping
fun create(
@AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
@RequestBody body: CreateTranslationSelectionRequest
) = ApiResponse.ok(
requests.create(
member?.id ?: throw TranslationSelectionError.INVALID_REQUEST.exception(),
body.clientRequestId,
body.scope
).response()
)
@GetMapping("/{requestId}")
fun summary(@PathVariable requestId: Long) = ApiResponse.ok(requests.get(requestId).response())
@GetMapping("/{requestId}/contents")
fun contents(
@PathVariable requestId: Long,
@RequestParam(required = false) afterContentId: Long?,
@RequestParam(defaultValue = "50") size: Int
) = ApiResponse.ok(contents.contents(requestId, afterContentId, size))
@GetMapping("/{requestId}/grouping")
fun grouping(@PathVariable requestId: Long) = ApiResponse.ok(grouping.get(requestId))
@PutMapping("/{requestId}/grouping")
fun review(@PathVariable requestId: Long, @RequestBody body: ReviewTranslationSelectionGroupingRequest) =
ApiResponse.ok(grouping.review(requestId, body))
@PostMapping("/{requestId}/cancel")
fun cancel(@PathVariable requestId: Long) = ApiResponse.ok(requests.cancel(requestId).response())
@PostMapping("/{requestId}/generate")
fun generate(@PathVariable requestId: Long, @RequestBody body: GenerateTranslationSelectionRequest) =
ApiResponse.ok(generation.generate(requestId, body.expectedRevision).response())
@GetMapping("/{requestId}/candidates")
fun candidates(
@PathVariable requestId: Long,
@RequestParam(required = false) afterCandidateId: Long?,
@RequestParam(defaultValue = "50") size: Int
) = ApiResponse.ok(candidates.page(requestId, afterCandidateId, size))
@PostMapping("/{requestId}/apply")
fun apply(
@PathVariable requestId: Long,
@AuthenticationPrincipal(expression = "#this == 'anonymousUser' ? null : member") member: Member?,
@RequestBody body: ApplyTranslationSelectionRequest
) = ApiResponse.ok(
applyService.apply(requestId, member?.id ?: throw TranslationSelectionError.INVALID_REQUEST.exception(), body)
)
}
@@ -0,0 +1,17 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import kr.co.vividnext.sodalive.common.SodaExceptionHandler
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import org.springframework.core.Ordered
import org.springframework.core.annotation.Order
import org.springframework.http.converter.HttpMessageNotReadableException
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.RestControllerAdvice
import org.springframework.web.method.annotation.MethodArgumentTypeMismatchException
@RestControllerAdvice(assignableTypes = [AdminTranslationSelectionController::class])
@Order(Ordered.HIGHEST_PRECEDENCE)
class TranslationSelectionInputExceptionHandler(private val handler: SodaExceptionHandler) {
@ExceptionHandler(HttpMessageNotReadableException::class, MethodArgumentTypeMismatchException::class)
fun invalidInput() = handler.handleSodaException(TranslationSelectionError.INVALID_REQUEST.exception())
}
@@ -0,0 +1,63 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvenance
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import java.time.LocalDateTime
import javax.persistence.AttributeConverter
import javax.persistence.Column
import javax.persistence.Convert
import javax.persistence.Converter
import javax.persistence.Entity
import javax.persistence.EnumType
import javax.persistence.Enumerated
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id
import javax.persistence.Table
import javax.persistence.UniqueConstraint
@Entity
@Table(
name = "content_translation_override",
uniqueConstraints = [
UniqueConstraint(name = "uk_content_translation_override_field", columnNames = ["content_id", "locale", "field_key"])
]
)
class ContentTranslationOverrideEntity(
@Column(name = "content_id", nullable = false)
val contentId: Long,
@Column(nullable = false, length = 10)
val locale: String,
@Enumerated(EnumType.STRING)
@Column(name = "field_key", nullable = false, length = 10)
val fieldKey: ContentSourceFieldKey,
@Column(nullable = false, length = 67)
var sourceFingerprint: String,
@Column(nullable = false, columnDefinition = "text")
var approvedText: String,
@Convert(converter = ApprovalProvenanceConverter::class)
@Column(nullable = false, columnDefinition = "text")
var provenance: ApprovalProvenance,
@Column(nullable = false, columnDefinition = "timestamp")
var approvedAt: LocalDateTime,
@Column(nullable = false, columnDefinition = "timestamp")
val createdAt: LocalDateTime = approvedAt,
@Column(nullable = false, columnDefinition = "timestamp")
var updatedAt: LocalDateTime = approvedAt
) {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
var id: Long? = null
}
@Converter
class ApprovalProvenanceConverter : AttributeConverter<ApprovalProvenance, String> {
override fun convertToDatabaseColumn(attribute: ApprovalProvenance): String = mapper.writeValueAsString(attribute)
override fun convertToEntityAttribute(dbData: String): ApprovalProvenance = mapper.readValue(dbData)
companion object {
private val mapper = jacksonObjectMapper()
}
}
@@ -0,0 +1,10 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Lock
import javax.persistence.LockModeType
interface ContentTranslationOverrideRepository : JpaRepository<ContentTranslationOverrideEntity, Long> {
@Lock(LockModeType.PESSIMISTIC_WRITE)
fun findByContentId(contentId: Long): List<ContentTranslationOverrideEntity>
}
@@ -0,0 +1,56 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentFieldApproval
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentTranslationOverride
import kr.co.vividnext.sodalive.v2.contenttranslation.port.ContentTranslationOverrideStore
import org.springframework.stereotype.Component
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Component
class JpaContentTranslationOverrideStore(
private val repository: ContentTranslationOverrideRepository,
private val entityManager: EntityManager
) : ContentTranslationOverrideStore {
override fun findByContentId(contentId: Long): List<ContentTranslationOverride> = rows(contentId).map {
ContentTranslationOverride(
it.contentId,
it.locale,
ContentFieldApproval(it.fieldKey, it.sourceFingerprint, it.approvedText, it.provenance),
it.approvedAt
)
}
override fun save(override: ContentTranslationOverride) {
val approval = override.approval
val existing = rows(override.contentId).singleOrNull { it.locale == override.locale && it.fieldKey == approval.field }
if (existing == null) {
repository.save(
ContentTranslationOverrideEntity(
override.contentId,
override.locale,
approval.field,
approval.sourceFingerprint,
approval.translatedText,
approval.provenance,
override.approvedAt
)
)
} else {
existing.sourceFingerprint = approval.sourceFingerprint
existing.approvedText = approval.translatedText
existing.provenance = approval.provenance
existing.approvedAt = override.approvedAt
existing.updatedAt = override.approvedAt
}
}
override fun deleteFields(contentId: Long, fields: Set<ContentSourceFieldKey>, locale: String?) {
rows(contentId).filter { it.fieldKey in fields && (locale == null || it.locale == locale) }.forEach(repository::delete)
}
private fun rows(contentId: Long): List<ContentTranslationOverrideEntity> = repository.findByContentId(contentId).onEach {
entityManager.refresh(it, LockModeType.PESSIMISTIC_WRITE)
}
}
@@ -0,0 +1,137 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionCandidateProgress
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import org.springframework.stereotype.Component
import java.time.LocalDateTime
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Component
class JpaTranslationCandidateStore(private val entityManager: EntityManager) : TranslationCandidateStore {
override fun save(candidate: TranslationCandidate): TranslationCandidate {
val row = if (candidate.candidateId == 0L) {
TranslationCandidateEntity(
entityManager.getReference(TranslationSelectionRequestEntity::class.java, candidate.requestId),
candidate.unit.key, candidate.unit, candidate.provider.id, candidate.provider.version, candidate.targetLanguage,
candidate.status, candidate.translatedValues, candidate.failureCode, candidate.attempt, candidate.leaseUntil,
candidate.fence, candidate.createdAt, candidate.updatedAt, candidate.terminalAt, candidate.linkedCandidateId
).also { entityManager.persist(it) }
} else {
entityManager.getReference(TranslationCandidateEntity::class.java, candidate.candidateId).apply {
status = candidate.status
translatedValues = candidate.translatedValues
failureCode = candidate.failureCode
attempt = candidate.attempt
leaseUntil = candidate.leaseUntil
fence = candidate.fence
updatedAt = candidate.updatedAt
terminalAt = candidate.terminalAt
}
}
entityManager.flush()
return row.domain()
}
override fun nextRequest(now: LocalDateTime): Long? = entityManager.createQuery(
"select c.request.id from TranslationCandidateEntity c where c.request.status = :generating and " +
"c.linkedCandidateId is null and (c.status = :pending or (c.status = :running and c.leaseUntil <= :now)) " +
"order by c.id",
java.lang.Long::class.java
).setParameter("generating", TranslationSelectionStatus.GENERATING)
.setParameter("pending", TranslationCandidateStatus.PENDING).setParameter("running", TranslationCandidateStatus.RUNNING)
.setParameter("now", now)
.setMaxResults(1).resultList.firstOrNull()?.toLong()
override fun lockNext(requestId: Long, now: LocalDateTime): TranslationCandidate? = entityManager.createQuery(
"select c from TranslationCandidateEntity c where c.request.id = :requestId and " +
"c.linkedCandidateId is null and (c.status = :pending or (c.status = :running and c.leaseUntil <= :now)) " +
"order by c.id",
TranslationCandidateEntity::class.java
).setParameter("requestId", requestId).setParameter("pending", TranslationCandidateStatus.PENDING)
.setParameter("running", TranslationCandidateStatus.RUNNING).setParameter("now", now)
.setLockMode(LockModeType.PESSIMISTIC_WRITE).setMaxResults(1).resultList.firstOrNull()
?.let { lock(requireNotNull(it.id)) }
override fun find(candidateId: Long): TranslationCandidate? =
entityManager.find(TranslationCandidateEntity::class.java, candidateId)?.domain()
override fun lock(candidateId: Long): TranslationCandidate? {
val row = entityManager.find(TranslationCandidateEntity::class.java, candidateId, LockModeType.PESSIMISTIC_WRITE)
?: return null
entityManager.refresh(row, LockModeType.PESSIMISTIC_WRITE)
return row.domain()
}
override fun page(requestId: Long, afterId: Long, limit: Int): List<TranslationCandidate> = entityManager.createQuery(
"select c from TranslationCandidateEntity c where c.request.id = :requestId and c.id > :afterId order by c.id",
TranslationCandidateEntity::class.java
).setParameter("requestId", requestId).setParameter("afterId", afterId).setMaxResults(limit).resultList.map { it.domain() }
override fun progress(requestId: Long): SelectionCandidateProgress {
val counts = entityManager.createQuery(
"select new kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.TranslationCandidateCount" +
"(c.status, count(c)) from TranslationCandidateEntity c where c.request.id = :requestId group by c.status",
TranslationCandidateCount::class.java
).setParameter("requestId", requestId).resultList.associate { it.status to it.count.toInt() }
val succeeded = counts[TranslationCandidateStatus.SUCCEEDED] ?: 0
val failed = counts[TranslationCandidateStatus.FAILED] ?: 0
return SelectionCandidateProgress(
counts.values.sum(),
succeeded + failed + (counts[TranslationCandidateStatus.DISCARDED] ?: 0),
succeeded,
failed
)
}
override fun discard(requestId: Long, now: LocalDateTime) {
discardUnselected(requestId, emptySet(), now)
}
override fun discardUnselected(requestId: Long, selectedIds: Set<Long>, now: LocalDateTime): Int {
val rows = entityManager.createQuery(
"select c from TranslationCandidateEntity c where c.request.id = :requestId order by c.id",
TranslationCandidateEntity::class.java
).setParameter("requestId", requestId).setLockMode(LockModeType.PESSIMISTIC_WRITE).resultList
val discarded = rows.filter { it.id !in selectedIds }
discarded.forEach {
it.status = TranslationCandidateStatus.DISCARDED
it.translatedValues = null
it.failureCode = null
it.leaseUntil = null
it.fence++
it.updatedAt = now
it.terminalAt = now
}
entityManager.flush()
return discarded.size
}
override fun completeLinked(source: TranslationCandidate) {
val rows = entityManager.createQuery(
"select c from TranslationCandidateEntity c where c.request.id = :requestId " +
"and c.linkedCandidateId = :sourceId order by c.id",
TranslationCandidateEntity::class.java
).setParameter("requestId", source.requestId).setParameter("sourceId", source.candidateId)
.setLockMode(LockModeType.PESSIMISTIC_WRITE).resultList
rows.forEach {
it.status = source.status
it.translatedValues = source.translatedValues
it.failureCode = source.failureCode
it.updatedAt = source.updatedAt
it.terminalAt = source.terminalAt
}
entityManager.flush()
}
private fun TranslationCandidateEntity.domain() = TranslationCandidate(
requireNotNull(id), requireNotNull(request.id), unit, ApprovalProvider(providerId, providerVersion), targetLanguage,
status, translatedValues, failureCode, attempt, leaseUntil, fence, createdAt, updatedAt, terminalAt, linkedCandidateId
)
}
data class TranslationCandidateCount(val status: TranslationCandidateStatus, val count: Long)
@@ -0,0 +1,73 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Component
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.util.UUID
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Component
class JpaTranslationSelectionStore(
private val repository: TranslationSelectionRequestRepository,
private val entityManager: EntityManager,
private val candidates: TranslationCandidateStore
) : TranslationSelectionStore {
override fun find(requestId: Long): TranslationSelectionRequest? = repository.findById(requestId).orElse(null)?.domain()
override fun findCreation(adminId: Long, clientRequestId: UUID): TranslationSelectionRequest? =
repository.findByCreatedByAndClientRequestId(adminId, clientRequestId.toString())?.domain()
override fun lock(requestId: Long): TranslationSelectionRequest? {
val row = entityManager.find(TranslationSelectionRequestEntity::class.java, requestId, LockModeType.PESSIMISTIC_WRITE)
?: return null
entityManager.refresh(row, LockModeType.PESSIMISTIC_WRITE)
return row.domain()
}
override fun nextPreparation(now: LocalDateTime): TranslationSelectionRequest? = entityManager.createQuery(
"select r from TranslationSelectionRequestEntity r where r.status = :status " +
"and (r.preparationLeaseUntil is null or r.preparationLeaseUntil <= :now) order by r.id",
TranslationSelectionRequestEntity::class.java
).setParameter("status", TranslationSelectionStatus.PREPARING).setParameter("now", now)
.setLockMode(LockModeType.PESSIMISTIC_WRITE).setMaxResults(1).resultList.firstOrNull()
?.let { lock(requireNotNull(it.id)) }
override fun save(request: TranslationSelectionRequest): TranslationSelectionRequest {
val row = if (request.requestId == 0L) {
TranslationSelectionRequestEntity(
request.createdBy, request.clientRequestId.toString(), request.bodyHash, request.scope,
request.status, request.revision, request.snapshot, request.preparationAttempt,
request.preparationLeaseUntil, request.preparationFence, request.errorCode, request.createdAt, request.updatedAt
)
} else {
entityManager.getReference(TranslationSelectionRequestEntity::class.java, request.requestId).apply {
status = request.status
revision = request.revision
snapshot = request.snapshot
preparationAttempt = request.preparationAttempt
preparationLeaseUntil = request.preparationLeaseUntil
preparationFence = request.preparationFence
errorCode = request.errorCode
updatedAt = request.updatedAt
}
}
row.acceptedGenerateRevision = request.acceptedGenerateRevision
row.applyOperationId = request.applyOperationId?.toString()
row.applyBodyHash = request.applyBodyHash
row.applyReceipt = request.applyReceipt
row.appliedAt = request.applyReceipt?.appliedAt?.atOffset(ZoneOffset.UTC)?.toLocalDateTime()
return repository.saveAndFlush(row).domain()
}
private fun TranslationSelectionRequestEntity.domain() = TranslationSelectionRequest(
requireNotNull(id), createdBy, UUID.fromString(clientRequestId), bodyHash, scope, status, revision, snapshot,
preparationAttempt, preparationLeaseUntil, preparationFence, errorCode, createdAt, updatedAt,
acceptedGenerateRevision, candidates.progress(requireNotNull(id)), applyOperationId?.let(UUID::fromString),
applyBodyHash, applyReceipt
)
}
@@ -0,0 +1,85 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateFailure
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationGenerationUnit
import org.springframework.data.jpa.repository.JpaRepository
import java.time.LocalDateTime
import javax.persistence.AttributeConverter
import javax.persistence.Column
import javax.persistence.Convert
import javax.persistence.Converter
import javax.persistence.Entity
import javax.persistence.EnumType
import javax.persistence.Enumerated
import javax.persistence.FetchType
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id
import javax.persistence.Index
import javax.persistence.JoinColumn
import javax.persistence.ManyToOne
import javax.persistence.Table
import javax.persistence.UniqueConstraint
@Entity
@Table(
name = "translation_candidate",
uniqueConstraints = [
UniqueConstraint(
name = "uk_translation_candidate_unit",
columnNames = ["request_id", "unit_key", "provider_id", "target_language"]
)
],
indexes = [Index(name = "ix_translation_candidate_claim", columnList = "request_id,status,lease_until,id")]
)
class TranslationCandidateEntity(
@ManyToOne(fetch = FetchType.LAZY, optional = false)
@JoinColumn(name = "request_id", nullable = false)
val request: TranslationSelectionRequestEntity,
@Column(name = "unit_key", nullable = false, length = 160) val unitKey: String,
@Convert(converter = TranslationGenerationUnitConverter::class)
@Column(nullable = false, columnDefinition = "longtext")
val unit: TranslationGenerationUnit,
@Column(name = "provider_id", nullable = false, length = 20) val providerId: String,
@Column(nullable = false, length = 80) val providerVersion: String,
@Column(name = "target_language", nullable = false, length = 10) val targetLanguage: String,
@Enumerated(EnumType.STRING)
@Column(nullable = false, length = 16)
var status: TranslationCandidateStatus,
@Convert(converter = CandidateValuesConverter::class)
@Column(columnDefinition = "longtext")
var translatedValues: List<String>?,
@Enumerated(EnumType.STRING)
@Column(length = 40)
var failureCode: TranslationCandidateFailure?,
@Column(nullable = false) var attempt: Int,
@Column(name = "lease_until", columnDefinition = "timestamp") var leaseUntil: LocalDateTime?,
@Column(nullable = false) var fence: Long,
@Column(nullable = false, columnDefinition = "timestamp") val createdAt: LocalDateTime,
@Column(nullable = false, columnDefinition = "timestamp") var updatedAt: LocalDateTime,
@Column(columnDefinition = "timestamp") var terminalAt: LocalDateTime?,
val linkedCandidateId: Long?
) {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
var id: Long? = null
}
interface TranslationCandidateRepository : JpaRepository<TranslationCandidateEntity, Long>
@Converter
class TranslationGenerationUnitConverter : AttributeConverter<TranslationGenerationUnit, String> {
override fun convertToDatabaseColumn(attribute: TranslationGenerationUnit): String = mapper.writeValueAsString(attribute)
override fun convertToEntityAttribute(dbData: String): TranslationGenerationUnit = mapper.readValue(dbData)
companion object { private val mapper = jacksonObjectMapper() }
}
@Converter
class CandidateValuesConverter : AttributeConverter<List<String>?, String?> {
override fun convertToDatabaseColumn(attribute: List<String>?): String? = attribute?.let { mapper.writeValueAsString(it) }
override fun convertToEntityAttribute(dbData: String?): List<String>? = dbData?.let { mapper.readValue(it) }
companion object { private val mapper = jacksonObjectMapper() }
}
@@ -0,0 +1,98 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import com.fasterxml.jackson.module.kotlin.readValue
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionRequestSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionApplyReceipt
import java.time.LocalDateTime
import javax.persistence.AttributeConverter
import javax.persistence.Column
import javax.persistence.Convert
import javax.persistence.Converter
import javax.persistence.Entity
import javax.persistence.EnumType
import javax.persistence.Enumerated
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id
import javax.persistence.Index
import javax.persistence.Table
import javax.persistence.UniqueConstraint
@Entity
@Table(
name = "translation_selection_request",
uniqueConstraints = [
UniqueConstraint(name = "uk_translation_selection_creation", columnNames = ["created_by", "client_request_id"])
],
indexes = [Index(name = "ix_translation_selection_prepare", columnList = "status,preparation_lease_until,id")]
)
class TranslationSelectionRequestEntity(
@Column(name = "created_by", nullable = false) val createdBy: Long,
@Column(name = "client_request_id", nullable = false, length = 36) val clientRequestId: String,
@Column(nullable = false, length = 64) val bodyHash: String,
@Convert(converter = SelectionScopeConverter::class)
@Column(nullable = false, columnDefinition = "text")
val scope: TranslationSelectionScope,
@Enumerated(EnumType.STRING)
@Column(nullable = false, length = 24)
var status: TranslationSelectionStatus,
@Column(nullable = false) var revision: Long,
@Convert(converter = SelectionSnapshotConverter::class)
@Column(nullable = false, columnDefinition = "longtext")
var snapshot: SelectionRequestSnapshot,
@Column(nullable = false) var preparationAttempt: Int,
@Column(name = "preparation_lease_until", columnDefinition = "timestamp") var preparationLeaseUntil: LocalDateTime?,
@Column(nullable = false) var preparationFence: Long,
@Enumerated(EnumType.STRING)
@Column(length = 40)
var errorCode: TranslationSelectionError?,
@Column(nullable = false, columnDefinition = "timestamp") val createdAt: LocalDateTime,
@Column(nullable = false, columnDefinition = "timestamp") var updatedAt: LocalDateTime
) {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
var id: Long? = null
var acceptedGenerateRevision: Long? = null
@Column(length = 36)
var applyOperationId: String? = null
@Column(length = 64)
var applyBodyHash: String? = null
@Column(columnDefinition = "longtext")
@Convert(converter = SelectionReceiptConverter::class)
var applyReceipt: TranslationSelectionApplyReceipt? = null
@Column(columnDefinition = "timestamp")
var appliedAt: LocalDateTime? = null
}
@Converter
class SelectionReceiptConverter : AttributeConverter<TranslationSelectionApplyReceipt?, String?> {
override fun convertToDatabaseColumn(attribute: TranslationSelectionApplyReceipt?): String? =
attribute?.let { mapper.writeValueAsString(it) }
override fun convertToEntityAttribute(dbData: String?): TranslationSelectionApplyReceipt? =
dbData?.let { mapper.readValue(it) }
companion object { private val mapper = jacksonObjectMapper().registerModule(JavaTimeModule()) }
}
@Converter
class SelectionScopeConverter : AttributeConverter<TranslationSelectionScope, String> {
override fun convertToDatabaseColumn(attribute: TranslationSelectionScope): String = mapper.writeValueAsString(attribute)
override fun convertToEntityAttribute(dbData: String): TranslationSelectionScope = mapper.readValue(dbData)
companion object { private val mapper = jacksonObjectMapper() }
}
@Converter
class SelectionSnapshotConverter : AttributeConverter<SelectionRequestSnapshot, String> {
override fun convertToDatabaseColumn(attribute: SelectionRequestSnapshot): String = mapper.writeValueAsString(attribute)
override fun convertToEntityAttribute(dbData: String): SelectionRequestSnapshot = mapper.readValue(dbData)
companion object { private val mapper = jacksonObjectMapper() }
}
@@ -0,0 +1,7 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence
import org.springframework.data.jpa.repository.JpaRepository
interface TranslationSelectionRequestRepository : JpaRepository<TranslationSelectionRequestEntity, Long> {
fun findByCreatedByAndClientRequestId(createdBy: Long, clientRequestId: String): TranslationSelectionRequestEntity?
}
@@ -0,0 +1,30 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.scheduler
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionPreparationService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionWorkerService
import org.redisson.api.RedissonClient
import org.springframework.scheduling.annotation.Scheduled
import org.springframework.stereotype.Component
import java.util.concurrent.TimeUnit
@Component
class TranslationSelectionWorker(
private val preparation: TranslationSelectionPreparationService,
private val candidates: TranslationSelectionWorkerService,
private val redisson: RedissonClient
) {
@Scheduled(fixedDelayString = "\${sodalive.translation-selection.fixed-delay-ms:1000}")
fun runPendingRequests() {
val lock = redisson.getLock("lock:translation-selection")
if (!lock.tryLock(0, 180, TimeUnit.SECONDS)) return
try {
try {
candidates.runNext()
} finally {
preparation.prepareNext()
}
} finally {
if (lock.isHeldByCurrentThread) lock.unlock()
}
}
}
@@ -0,0 +1,44 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContentRepository
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceSnapshot
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
@Service
class ContentTranslationLanguageService(
private val repository: AudioContentRepository,
private val detector: LanguageDetectionCacheService,
private val writer: ContentTranslationWriteService,
private val invalidation: ContentTranslationSourceInvalidationService,
transactionManager: PlatformTransactionManager
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun detectMissing(contentId: Long, expectedQuery: String? = null): ContentSourceSnapshot? {
val before = transaction.execute {
repository.findById(contentId).orElse(null)?.toContentSourceSnapshot()
} ?: return null
if (!before.sourceLanguage.isNullOrBlank() || (expectedQuery != null && before.detectionQuery != expectedQuery)) {
return before
}
val detected = detector.detectWithCache(before.detectionQuery)?.detectedLanguage ?: return before
return transaction.execute {
val content = writer.lockContent(contentId) ?: return@execute null
val current = content.toContentSourceSnapshot()
if (current == before) {
content.languageCode = detected
invalidation.invalidateChanged(content, current)
}
content.toContentSourceSnapshot()
}
}
}
@@ -0,0 +1,87 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.port.ContentTranslationOverrideStore
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Service
class ContentTranslationSourceInvalidationService(
private val writer: ContentTranslationWriteService,
private val overrides: ContentTranslationOverrideStore,
private val translations: ContentTranslationRepository,
private val scheduler: TranslationJobScheduler,
private val entityManager: EntityManager
) {
@Transactional
fun lock(content: AudioContent) = writer.lockContent(content)
@Transactional
fun invalidateChanged(content: AudioContent, before: ContentSourceSnapshot) {
val after = content.toContentSourceSnapshot()
val changed = ContentSourceFieldKey.values().filter { before.fingerprint(it) != after.fingerprint(it) }.toSet()
if (changed.isEmpty()) return
val contentId = requireNotNull(content.id)
overrides.deleteFields(contentId, changed)
fallback(contentId, after, changed)
schedule(contentId, after, changed)
}
@Transactional
fun invalidateStale(content: AudioContent) {
val contentId = requireNotNull(content.id)
val source = content.toContentSourceSnapshot()
val stale = overrides.findByContentId(contentId).filter {
it.approval.sourceFingerprint != source.fingerprint(it.approval.field)
}
stale.groupBy { it.locale }.forEach { (locale, rows) ->
val fields = rows.map { it.approval.field }.toSet()
overrides.deleteFields(contentId, fields, locale)
fallback(contentId, source, fields, locale)
schedule(contentId, source, fields)
}
}
private fun fallback(
contentId: Long,
source: ContentSourceSnapshot,
changed: Set<ContentSourceFieldKey>,
locale: String? = null
) {
translations.findByContentId(contentId).filter { locale == null || it.locale == locale }.forEach { row ->
entityManager.refresh(row, LockModeType.PESSIMISTIC_WRITE)
val previous = row.renderedPayload
row.renderedPayload = ContentTranslationPayload(
if (ContentSourceFieldKey.TITLE in changed) source.title else previous.title,
if (ContentSourceFieldKey.DETAIL in changed) source.detail else previous.detail,
if (ContentSourceFieldKey.TAGS in changed) source.tags.joinToString(",") else previous.tags
)
}
}
private fun schedule(contentId: Long, source: ContentSourceSnapshot, changed: Set<ContentSourceFieldKey>) {
val language = source.sourceLanguage?.takeIf { TranslationLanguages.isSupported(it) } ?: return
TranslationLanguages.getTranslatableLanguageCodes(language).forEach { target ->
source.fields.filter { field -> changed.any { it.key == field.fieldKey } }.forEach { field ->
scheduler.scheduleMissingTranslation(
LanguageTranslationTargetType.CONTENT,
contentId,
field.fieldKey,
field.sourceText,
language,
target,
refreshCompletedContentField = true
)
}
}
}
}
@@ -0,0 +1,54 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesContent
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import org.springframework.stereotype.Service
import javax.persistence.EntityManager
import javax.persistence.LockModeType
fun AudioContent.toContentSourceSnapshot(): ContentSourceSnapshot = ContentSourceSnapshot(
sourceLanguage = languageCode,
title = title,
detail = detail,
tags = audioContentHashTags
.filter { it.isActive }
.sortedWith(compareBy(nullsLast()) { it.id })
.mapNotNull { it.hashTag?.tag }
)
@Service
class ContentTranslationSourceService(
private val entityManager: EntityManager,
private val writer: ContentTranslationWriteService
) {
// Caller owns the request transaction; membership mutation uses the same Series parent lock.
fun lockScope(scope: TranslationSelectionScope): List<AudioContent>? = when (scope) {
is TranslationSelectionScope.Content -> writer.lockContent(scope.contentId)?.let { listOf(it) }
is TranslationSelectionScope.Series -> {
val series = entityManager.find(Series::class.java, scope.seriesId, LockModeType.PESSIMISTIC_WRITE)
if (series == null) {
null
} else {
entityManager.refresh(series, LockModeType.PESSIMISTIC_WRITE)
if (!series.isActive) {
null
} else {
linkedContentIds(scope.seriesId, true).mapNotNull(writer::lockContent).filter { it.isActive }
}
}
}
}
fun linkedContentIds(seriesId: Long, lock: Boolean = false): List<Long> {
val query = entityManager.createQuery(
"select s from SeriesContent s where s.series.id = :id order by s.content.id",
SeriesContent::class.java
).setParameter("id", seriesId)
if (lock) query.setLockMode(LockModeType.PESSIMISTIC_WRITE)
return query.resultList.onEach { if (lock) entityManager.refresh(it, LockModeType.PESSIMISTIC_WRITE) }
.map { requireNotNull(it.content?.id) }.distinct().sorted()
}
}
@@ -0,0 +1,137 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslationCoordinator
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentFieldApproval
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentTranslationOverride
import kr.co.vividnext.sodalive.v2.contenttranslation.port.ContentTranslationOverrideStore
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Service
class ContentTranslationWriteService(
private val entityManager: EntityManager,
private val translations: ContentTranslationRepository,
private val overrides: ContentTranslationOverrideStore,
private val coordinator: TranslationCoordinator,
private val nowProvider: () -> LocalDateTime = { LocalDateTime.now(ZoneOffset.UTC) }
) {
@Transactional
fun lockContent(contentId: Long): AudioContent? {
val content = entityManager.find(AudioContent::class.java, contentId, LockModeType.PESSIMISTIC_WRITE) ?: return null
lockContent(content)
return content
}
@Transactional
fun lockContent(content: AudioContent) {
entityManager.refresh(content, LockModeType.PESSIMISTIC_WRITE)
}
@Transactional
fun hasCurrentApproval(contentId: Long, locale: String, fieldKey: String): Boolean {
val source = lockContent(contentId)?.toContentSourceSnapshot() ?: return false
return overrides.findByContentId(contentId).any {
it.locale == locale.lowercase() && it.approval.field.key == fieldKey &&
it.approval.sourceFingerprint == source.fingerprint(it.approval.field)
}
}
@Transactional
fun approve(contentId: Long, locale: String, approvals: List<ContentFieldApproval>): List<ContentTranslationOverride> =
approve(contentId, locale, approvals, nowProvider())
@Transactional
fun approve(
contentId: Long,
locale: String,
approvals: List<ContentFieldApproval>,
approvedAt: LocalDateTime
): List<ContentTranslationOverride> {
val content = lockContent(contentId) ?: throw SodaException(messageKey = "admin.content.not_found")
val source = content.toContentSourceSnapshot()
if (approvals.any { it.sourceFingerprint != source.fingerprint(it.field) }) {
throw SodaException(messageKey = "common.error.invalid_request", errorProperty = "SOURCE_CHANGED")
}
require(approvals.isNotEmpty() && approvals.map { it.field }.distinct().size == approvals.size)
val target = locale.lowercase()
val now = approvedAt.truncatedTo(ChronoUnit.SECONDS)
val approved = approvals.map { ContentTranslationOverride(contentId, target, it, now) }
approved.forEach(overrides::save)
merge(contentId, target, source, approvals.associate { it.field to it.translatedText })
return approved
}
@Transactional
fun materialize(contentId: Long, locale: String): Boolean =
materialize(contentId, locale, ContentSourceFieldKey.values().toSet())
@Transactional
fun materialize(contentId: Long, locale: String, fields: Set<ContentSourceFieldKey>): Boolean {
val content = lockContent(contentId) ?: return false
val source = content.toContentSourceSnapshot()
val language = source.sourceLanguage?.takeIf { it.isNotBlank() } ?: return false
val target = locale.lowercase()
val selected = if (translations.findByContentIdAndLocaleForUpdate(contentId, target) == null) {
ContentSourceFieldKey.values().toSet()
} else {
fields
}
val approved = overrides.findByContentId(contentId).filter {
it.locale == target && it.approval.sourceFingerprint == source.fingerprint(it.approval.field)
}.associate { it.approval.field to it.approval.translatedText }
val values = mutableMapOf<ContentSourceFieldKey, String>()
selected.forEach { field ->
val raw = source.fields.single { it.fieldKey == field.key }.sourceText
values[field] = approved[field] ?: if (SourceTextNormalizer.normalize(raw).isBlank()) {
""
} else {
coordinator.findCached(
SourceTextNormalizer.hash(raw),
language.lowercase(),
target,
rejectUnchangedAwsResult = field == ContentSourceFieldKey.TAGS
)?.translatedText ?: return false
}
}
merge(contentId, target, source, values)
return true
}
private fun merge(
contentId: Long,
locale: String,
source: ContentSourceSnapshot,
values: Map<ContentSourceFieldKey, String>
) {
val existing = translations.findByContentIdAndLocaleForUpdate(contentId, locale)
if (existing != null) entityManager.refresh(existing, LockModeType.PESSIMISTIC_WRITE)
val previous = existing?.renderedPayload ?: ContentTranslationPayload(
source.title,
source.detail,
source.tags.joinToString(",")
)
val payload = ContentTranslationPayload(
values[ContentSourceFieldKey.TITLE] ?: previous.title,
values[ContentSourceFieldKey.DETAIL] ?: previous.detail,
values[ContentSourceFieldKey.TAGS] ?: previous.tags
)
if (existing == null) {
translations.save(ContentTranslation(contentId, locale, payload))
} else {
existing.renderedPayload = payload
}
}
}
@@ -0,0 +1,203 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvenance
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentFieldApproval
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationGenerationUnit
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationUnitKind
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ApplyTranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionAppliedField
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionApplyReceipt
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionChoice
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionField
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
@Service
class TranslationSelectionApplyService(
private val requests: TranslationSelectionStore,
private val candidates: TranslationCandidateStore,
private val sources: ContentTranslationSourceService,
private val writer: ContentTranslationWriteService,
private val nowProvider: () -> LocalDateTime = { LocalDateTime.now(ZoneOffset.UTC) }
) {
@Transactional
fun apply(requestId: Long, adminId: Long, body: ApplyTranslationSelectionRequest): TranslationSelectionApplyReceipt {
val request = requests.lock(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
val hash = body.canonicalHash()
if (adminId <= 0) throw TranslationSelectionError.INVALID_REQUEST.exception()
if (request.applyOperationId == body.operationId) {
if (request.applyBodyHash != hash) throw TranslationSelectionError.IDEMPOTENCY_CONFLICT.exception()
return requireNotNull(request.applyReceipt)
}
if (request.status.isTerminal()) throw TranslationSelectionError.REQUEST_CLOSED.exception()
if (request.status != TranslationSelectionStatus.READY) throw TranslationSelectionError.REQUEST_NOT_READY.exception()
if (request.revision != body.expectedRevision) throw TranslationSelectionError.REVISION_CONFLICT.exception()
if (body.selections.isEmpty()) throw TranslationSelectionError.INVALID_REQUEST.exception()
val current = sources.lockScope(request.scope).orEmpty()
.associate { requireNotNull(it.id) to it.toContentSourceSnapshot() }
if (body.selections.any { it is TranslationSelectionChoice.TitleGroup } &&
current.keys != request.snapshot.memberContentIds.toSet()
) {
throw TranslationSelectionError.MEMBERSHIP_CHANGED.exception()
}
val fields = body.selections.flatMap { choice ->
when (choice) {
is TranslationSelectionChoice.Field -> listOf(field(request, choice))
is TranslationSelectionChoice.TitleGroup -> group(request, choice)
}
}.sortedWith(compareBy({ it.contentId }, { it.targetLanguage }, { it.field.key }))
if (fields.map { Triple(it.contentId, it.field, it.targetLanguage) }.distinct().size != fields.size) {
throw TranslationSelectionError.INVALID_REQUEST.exception()
}
fields.forEach { field -> validateSource(request, field, current[field.contentId]) }
val now = nowProvider().truncatedTo(ChronoUnit.SECONDS)
fields.groupBy { it.contentId to it.targetLanguage }.forEach { (target, selected) ->
writer.approve(
target.first,
target.second,
selected.map {
val key = ContentSourceFieldKey.values().single { key -> key.key == it.field.key }
ContentFieldApproval(
key,
current.getValue(it.contentId).fingerprint(key),
it.translatedValue,
ApprovalProvenance(requestId, it.candidateIds, it.providers, adminId)
)
},
now
)
}
val discarded = candidates.discardUnselected(requestId, fields.flatMap { it.candidateIds }.toSet(), now)
val receipt = TranslationSelectionApplyReceipt(
requestId,
body.operationId,
TranslationSelectionStatus.APPLIED,
now.toInstant(ZoneOffset.UTC),
fields,
discarded
)
requests.save(
request.copy(
status = TranslationSelectionStatus.APPLIED,
revision = request.revision + 1,
updatedAt = now,
applyOperationId = body.operationId,
applyBodyHash = hash,
applyReceipt = receipt
)
)
return receipt
}
private fun field(
request: TranslationSelectionRequest,
choice: TranslationSelectionChoice.Field
): TranslationSelectionAppliedField {
if (choice.contentId <= 0 || choice.candidateId <= 0 ||
(
choice.field == TranslationSelectionField.TITLE &&
request.snapshot.grouping?.groups.orEmpty().any { choice.contentId in it.memberContentIds }
)
) {
throw TranslationSelectionError.INVALID_REQUEST.exception()
}
val unit = request.snapshot.generationUnits.singleOrNull {
it.kind == TranslationUnitKind.FIELD && it.contentId == choice.contentId && it.field?.key == choice.field.key
} ?: throw TranslationSelectionError.CANDIDATE_NOT_SELECTABLE.exception()
val selected = candidate(request, choice.candidateId, unit to choice.targetLanguage)
return TranslationSelectionAppliedField(
choice.contentId,
choice.field,
choice.targetLanguage,
requireNotNull(selected.translatedValues).single(),
listOf(selected.candidateId),
listOf(selected.provider)
)
}
private fun group(
request: TranslationSelectionRequest,
choice: TranslationSelectionChoice.TitleGroup
): List<TranslationSelectionAppliedField> {
val grouping = requireNotNull(request.snapshot.grouping)
val group = grouping.groups.singleOrNull { it.groupId == choice.groupId }
?: throw TranslationSelectionError.INCOMPLETE_TITLE_GROUP.exception()
if (choice.residualChoices.map { it.contentId }.sorted() != group.memberContentIds.sorted()) {
throw TranslationSelectionError.INCOMPLETE_TITLE_GROUP.exception()
}
val commonUnit = request.snapshot.generationUnits.single {
it.kind == TranslationUnitKind.GROUP_COMMON && it.groupId == group.groupId
}
val common = candidate(request, choice.commonCandidateId, commonUnit to choice.targetLanguage)
return choice.residualChoices.map { residualChoice ->
val template = grouping.templates.single { it.contentId == residualChoice.contentId }.template()
val residual = if (template.residualInputs.isEmpty()) {
if (residualChoice.candidateId != null) throw TranslationSelectionError.INCOMPLETE_TITLE_GROUP.exception()
null
} else {
val id = residualChoice.candidateId ?: throw TranslationSelectionError.INCOMPLETE_TITLE_GROUP.exception()
val residualUnit = request.snapshot.generationUnits.single {
it.kind == TranslationUnitKind.TITLE_RESIDUAL && it.groupId == group.groupId &&
it.contentId == residualChoice.contentId
}
candidate(request, id, residualUnit to choice.targetLanguage)
}
val contributing = listOfNotNull(common, residual)
TranslationSelectionAppliedField(
residualChoice.contentId,
TranslationSelectionField.TITLE,
choice.targetLanguage,
template.render(requireNotNull(common.translatedValues), residual?.translatedValues.orEmpty()),
contributing.map { it.candidateId },
contributing.map { it.provider }.distinct()
)
}
}
private fun candidate(
request: TranslationSelectionRequest,
candidateId: Long,
target: Pair<TranslationGenerationUnit, String>
): TranslationCandidate {
val (unit, language) = target
if (candidateId <= 0 || language !in TranslationLanguages.getTranslatableLanguageCodes(null)) {
throw TranslationSelectionError.INVALID_REQUEST.exception()
}
val candidate = candidates.lock(candidateId) ?: throw TranslationSelectionError.CANDIDATE_NOT_SELECTABLE.exception()
if (request.acceptedGenerateRevision == null || candidate.requestId != request.requestId ||
candidate.status != TranslationCandidateStatus.SUCCEEDED || candidate.unit != unit ||
candidate.provider !in request.snapshot.providerManifest || candidate.targetLanguage != language ||
language !in request.snapshot.targetLanguages ||
language !in TranslationLanguages.getTranslatableLanguageCodes(unit.sourceLanguage) ||
candidate.translatedValues?.size != unit.inputValues.size || candidate.translatedValues.any { it.isBlank() }
) {
throw TranslationSelectionError.CANDIDATE_NOT_SELECTABLE.exception()
}
return candidate
}
private fun validateSource(
request: TranslationSelectionRequest,
field: TranslationSelectionAppliedField,
current: ContentSourceSnapshot?
) {
val frozen = request.snapshot.contents.singleOrNull { it.contentId == field.contentId }
val key = ContentSourceFieldKey.values().single { it.key == field.field.key }
if (current == null || frozen == null || current.fingerprint(key) != frozen.source().fingerprint(key)) {
throw TranslationSelectionError.SOURCE_CHANGED.exception()
}
}
}
@@ -0,0 +1,38 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationCandidatesResponse
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.response
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
@Service
class TranslationSelectionCandidateQueryService(
private val requests: TranslationSelectionStore,
private val candidates: TranslationCandidateStore
) {
@Transactional(readOnly = true)
fun page(requestId: Long, afterCandidateId: Long?, size: Int): TranslationCandidatesResponse {
if (size !in 1..100 || (afterCandidateId != null && afterCandidateId <= 0)) {
throw TranslationSelectionError.INVALID_REQUEST.exception()
}
val request = requests.find(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
if (request.status in setOf(
TranslationSelectionStatus.PREPARING,
TranslationSelectionStatus.REVIEW_REQUIRED,
TranslationSelectionStatus.READY_TO_GENERATE
)
) {
throw TranslationSelectionError.REQUEST_NOT_READY.exception()
}
val page = candidates.page(requestId, afterCandidateId ?: 0, size + 1)
val items = page.take(size)
return TranslationCandidatesResponse(
items.map { it.response() },
if (page.size > size) items.last().candidateId else null
)
}
}
@@ -0,0 +1,120 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionContentSource
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionFieldValues
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.selectionFingerprints
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.SelectionApprovalOrigins
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.SelectionApprovalProvenances
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionApprovalOrigin
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionApprovalProvenance
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionContentResponse
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionContentsResponse
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionCurrentTranslation
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionField
import kr.co.vividnext.sodalive.v2.contenttranslation.port.ContentTranslationOverrideStore
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.ZoneOffset
import javax.persistence.EntityManager
import javax.persistence.LockModeType
@Service
class TranslationSelectionContentsService(
private val store: TranslationSelectionStore,
private val sources: ContentTranslationSourceService,
private val writer: ContentTranslationWriteService,
private val translations: ContentTranslationRepository,
private val overrides: ContentTranslationOverrideStore,
private val entityManager: EntityManager
) {
@Transactional
fun contents(requestId: Long, afterContentId: Long?, size: Int): TranslationSelectionContentsResponse {
if (size !in 1..100 || (afterContentId != null && afterContentId <= 0)) {
throw TranslationSelectionError.INVALID_REQUEST.exception()
}
val request = store.find(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
val page = request.snapshot.contents.filter { it.contentId > (afterContentId ?: 0) }
.sortedBy { it.contentId }.take(size + 1)
val linked = when (val scope = request.scope) {
is TranslationSelectionScope.Content -> null
is TranslationSelectionScope.Series -> if (entityManager.find(Series::class.java, scope.seriesId)?.isActive == true) {
sources.linkedContentIds(scope.seriesId).toSet()
} else {
emptySet()
}
}
val items = page.take(size).map { source -> item(source, linked) }
return TranslationSelectionContentsResponse(items, if (page.size > size) items.last().contentId else null)
}
private fun item(source: SelectionContentSource, linked: Set<Long>?): TranslationSelectionContentResponse {
val content = writer.lockContent(source.contentId)
val current = content?.toContentSourceSnapshot()
val active = content?.isActive == true
val approved = if (current == null) {
emptyList()
} else {
overrides.findByContentId(source.contentId).filter {
it.approval.sourceFingerprint == current.fingerprint(it.approval.field)
}
}
val currentTranslations = TranslationLanguages.getTranslatableLanguageCodes(source.sourceLanguage).map { locale ->
val row = translations.findByContentIdAndLocaleForUpdate(source.contentId, locale)
if (row != null) entityManager.refresh(row, LockModeType.PESSIMISTIC_WRITE)
val fallback = current ?: source.source()
val fields = row?.renderedPayload?.let { SelectionFieldValues(it.title, it.detail, it.tags) }
?: SelectionFieldValues(fallback.title, fallback.detail, fallback.tags.joinToString(","))
val provenance = ContentSourceFieldKey.values().associateWith { field ->
approved.singleOrNull { it.locale == locale && it.approval.field == field }?.let {
val origin = it.approval.provenance
TranslationSelectionApprovalProvenance(
origin.requestId,
origin.candidateIds,
origin.providers,
origin.approvedBy,
it.approvedAt.toInstant(ZoneOffset.UTC)
)
}
}
fun origin(field: ContentSourceFieldKey) = if (provenance[field] == null) {
TranslationSelectionApprovalOrigin.UNKNOWN
} else {
TranslationSelectionApprovalOrigin.ADMIN
}
TranslationSelectionCurrentTranslation(
locale,
fields,
SelectionApprovalOrigins(
origin(ContentSourceFieldKey.TITLE),
origin(ContentSourceFieldKey.DETAIL),
origin(ContentSourceFieldKey.TAGS)
),
SelectionApprovalProvenances(
provenance[ContentSourceFieldKey.TITLE],
provenance[ContentSourceFieldKey.DETAIL],
provenance[ContentSourceFieldKey.TAGS]
)
)
}
return TranslationSelectionContentResponse(
source.contentId,
active,
content != null && (linked == null || (active && source.contentId in linked)),
requireNotNull(source.sourceLanguage),
SelectionFieldValues(source.title, source.detail, source.tags.joinToString(",")),
source.sourceFingerprints,
current?.selectionFingerprints(),
source.source().fields.filter { it.sourceText.isBlank() }.map { field ->
TranslationSelectionField.values().single { it.key == field.fieldKey }
},
currentTranslations
)
}
}
@@ -0,0 +1,128 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.i18n.translation.TranslationProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TitleSegmentKind
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationGenerationUnit
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationUnitKind
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
@Service
class TranslationSelectionGenerationService(
private val requests: TranslationSelectionStore,
private val candidates: TranslationCandidateStore,
private val providers: List<TranslationProvider>,
private val nowProvider: () -> LocalDateTime = { LocalDateTime.now(ZoneOffset.UTC) }
) {
@Transactional
fun generate(requestId: Long, expectedRevision: Long): TranslationSelectionRequest {
val request = requests.lock(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
if (request.acceptedGenerateRevision == expectedRevision) return request
if (request.status.isTerminal()) throw TranslationSelectionError.REQUEST_CLOSED.exception()
if (!request.snapshot.reviewed) throw TranslationSelectionError.REVIEW_REQUIRED.exception()
if (request.revision != expectedRevision) throw TranslationSelectionError.REVISION_CONFLICT.exception()
if (request.status != TranslationSelectionStatus.READY_TO_GENERATE) {
throw TranslationSelectionError.REQUEST_NOT_READY.exception()
}
val now = nowProvider().truncatedTo(ChronoUnit.SECONDS)
val units = units(request)
val manifest = providers.map { ApprovalProvider(it.providerId.code, it.providerVersion) }.sortedBy { it.id }
val inputs = mutableMapOf<ProviderInput, Long>()
units.forEach { unit ->
manifest.forEach { provider ->
TranslationLanguages.getTranslatableLanguageCodes(unit.sourceLanguage).forEach { language ->
val input = ProviderInput(provider, language, unit.sourceLanguage, unit.kind, unit.field, unit.inputValues)
val candidate = candidates.save(
TranslationCandidate(
requestId = requestId,
unit = unit,
provider = provider,
targetLanguage = language,
createdAt = now,
linkedCandidateId = inputs[input]
)
)
inputs.putIfAbsent(input, candidate.candidateId)
}
}
}
return requests.save(
request.copy(
status = if (candidates.progress(requestId).total == 0) {
TranslationSelectionStatus.READY
} else {
TranslationSelectionStatus.GENERATING
},
revision = request.revision + 1,
acceptedGenerateRevision = expectedRevision,
updatedAt = now,
snapshot = request.snapshot.copy(generationUnits = units, providerManifest = manifest)
)
)
}
private data class ProviderInput(
val provider: ApprovalProvider,
val target: String,
val source: String,
val kind: TranslationUnitKind,
val field: ContentSourceFieldKey?,
val values: List<String>
)
private fun units(request: TranslationSelectionRequest): List<TranslationGenerationUnit> {
val grouping = requireNotNull(request.snapshot.grouping)
val grouped = grouping.groups.flatMap { it.memberContentIds }.toSet()
val fields = request.snapshot.contents.flatMap { content ->
content.source().fields.filter {
it.sourceText.isNotBlank() && (it.fieldKey != "title" || content.contentId !in grouped)
}.map {
TranslationGenerationUnit(
"field:${content.contentId}:${it.fieldKey}",
TranslationUnitKind.FIELD,
requireNotNull(content.sourceLanguage),
listOf(it.sourceText),
content.contentId,
ContentSourceFieldKey.values().single { field -> field.key == it.fieldKey }
)
}
}
val common = grouping.groups.mapIndexed { index, group ->
TranslationGenerationUnit(
"common:$index",
TranslationUnitKind.GROUP_COMMON,
group.sourceLanguage,
group.sharedParts.map { it.sourceText },
groupId = group.groupId
)
}
val residuals = grouping.templates.mapNotNull { template ->
val values = template.segments.filter { it.kind == TitleSegmentKind.RESIDUAL }.map { it.sourceText }
if (values.isEmpty()) {
null
} else {
TranslationGenerationUnit(
"residual:${template.contentId}",
TranslationUnitKind.TITLE_RESIDUAL,
requireNotNull(request.snapshot.contents.single { it.contentId == template.contentId }.sourceLanguage),
values,
template.contentId,
groupId = template.groupId
)
}
}
return fields + common + residuals
}
}
@@ -0,0 +1,60 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TitleGroupingReview
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.groupingInputs
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.selectionSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ReviewTranslationSelectionGroupingRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionGroupingResponse
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
@Service
class TranslationSelectionGroupingService(private val store: TranslationSelectionStore) {
@Transactional(readOnly = true)
fun get(requestId: Long): TranslationSelectionGroupingResponse =
response(store.find(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception())
@Transactional
fun review(requestId: Long, body: ReviewTranslationSelectionGroupingRequest): TranslationSelectionGroupingResponse {
val request = store.lock(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
if (request.status.isTerminal()) throw TranslationSelectionError.REQUEST_CLOSED.exception()
if (request.status !in setOf(TranslationSelectionStatus.REVIEW_REQUIRED, TranslationSelectionStatus.READY_TO_GENERATE)) {
throw TranslationSelectionError.REQUEST_NOT_READY.exception()
}
if (body.expectedRevision != request.revision) throw TranslationSelectionError.REVISION_CONFLICT.exception()
val grouping = try {
TitleGroupingReview(body.groups, body.individualContentIds).validate(request.snapshot.contents.groupingInputs())
} catch (_: IllegalArgumentException) {
throw TranslationSelectionError.INVALID_GROUPING.exception()
}
return response(
store.save(
request.copy(
status = TranslationSelectionStatus.READY_TO_GENERATE,
revision = request.revision + 1,
snapshot = request.snapshot.copy(grouping = grouping.selectionSnapshot(), reviewed = true),
updatedAt = LocalDateTime.now(ZoneOffset.UTC).truncatedTo(ChronoUnit.SECONDS)
)
)
)
}
private fun response(request: TranslationSelectionRequest): TranslationSelectionGroupingResponse {
val grouping = request.snapshot.grouping ?: throw TranslationSelectionError.REQUEST_NOT_READY.exception()
return TranslationSelectionGroupingResponse(
request.requestId,
request.revision,
request.snapshot.reviewed,
grouping.groups,
grouping.individualContentIds,
grouping.templates
)
}
}
@@ -0,0 +1,179 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.i18n.translation.TranslationProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionContentSource
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TitleGroupingAnalyzer
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationPreparationClaim
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.groupingInputs
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.selectionFingerprints
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.selectionSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
@Service
class TranslationSelectionPreparationService(
private val store: TranslationSelectionStore,
private val sources: ContentTranslationSourceService,
private val detector: LanguageDetectionCacheService,
private val providers: List<TranslationProvider>,
transactionManager: PlatformTransactionManager,
private val nowProvider: () -> LocalDateTime = { LocalDateTime.now(ZoneOffset.UTC) }
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun prepareNext(): Boolean {
val claim = claimNext() ?: return false
processPrepare(claim)
return true
}
fun claimNext(): TranslationPreparationClaim? = transaction.execute {
val now = now()
val request = store.nextPreparation(now) ?: return@execute null
if (request.preparationAttempt >= 2) {
fail(request, TranslationSelectionError.PREPARATION_INTERRUPTED)
return@execute null
}
val current = currentSources(request) ?: return@execute null
val baseline = request.snapshot.preparationSources ?: current.map { it.selectionSource() }
val claimed = store.save(
request.copy(
preparationAttempt = request.preparationAttempt + 1,
preparationFence = request.preparationFence + 1,
preparationLeaseUntil = now.plusSeconds(60),
updatedAt = now,
snapshot = request.snapshot.copy(preparationSources = baseline)
)
)
TranslationPreparationClaim(claimed.requestId, claimed.preparationFence, baseline)
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun processPrepare(claim: TranslationPreparationClaim) {
val languages = mutableMapOf<Long, String>()
for (source in claim.sources) {
if (transaction.execute { checkedCurrent(claim) != null } != true) return
val language = source.sourceLanguage?.takeIf { it.isNotBlank() }
?: detector.detectWithCache(source.source().detectionQuery) {
transaction.execute { checkedCurrent(claim) != null } == true
}?.detectedLanguage
val accepted = transaction.execute {
val (request) = checkedCurrent(claim) ?: return@execute false
val error = when {
language.isNullOrBlank() -> TranslationSelectionError.LANGUAGE_DETECTION_FAILED
!TranslationLanguages.isSupported(language) -> TranslationSelectionError.UNSUPPORTED_SOURCE_LANGUAGE
else -> null
}
if (error != null) fail(request, error)
error == null
}
if (accepted != true) return
languages[source.contentId] = requireNotNull(language)
}
transaction.executeWithoutResult {
val (request, current) = checkedCurrent(claim) ?: return@executeWithoutResult
current.forEach { content ->
if (content.languageCode.isNullOrBlank()) content.languageCode = languages.getValue(requireNotNull(content.id))
}
val contents = current.map { it.selectionSource() }
val proposed = TitleGroupingAnalyzer().analyze(contents.groupingInputs())
store.save(
request.copy(
status = when (request.scope) {
is TranslationSelectionScope.Content -> TranslationSelectionStatus.READY_TO_GENERATE
is TranslationSelectionScope.Series -> TranslationSelectionStatus.REVIEW_REQUIRED
},
preparationLeaseUntil = null,
updatedAt = now(),
snapshot = request.snapshot.copy(
contents = contents,
grouping = proposed.selectionSnapshot(),
reviewed = request.scope is TranslationSelectionScope.Content,
providerManifest = providers.map { ApprovalProvider(it.providerId.code, it.providerVersion) }
.sortedBy { it.id },
targetLanguages = contents.flatMap {
TranslationLanguages.getTranslatableLanguageCodes(it.sourceLanguage)
}.distinct()
)
)
)
}
}
private fun checkedCurrent(claim: TranslationPreparationClaim): Pair<TranslationSelectionRequest, List<AudioContent>>? {
val request = store.lock(claim.requestId) ?: return null
val now = now()
if (request.status != TranslationSelectionStatus.PREPARING || request.preparationFence != claim.fence ||
request.preparationLeaseUntil?.isAfter(now) != true
) {
return null
}
val current = currentSources(request) ?: return null
val renewed = store.save(request.copy(preparationLeaseUntil = now.plusSeconds(60), updatedAt = now))
return renewed to current
}
private fun currentSources(request: TranslationSelectionRequest): List<AudioContent>? {
val current = sources.lockScope(request.scope)
val error = when {
current == null -> when (request.scope) {
is TranslationSelectionScope.Content -> TranslationSelectionError.SOURCE_CHANGED
is TranslationSelectionScope.Series -> TranslationSelectionError.MEMBERSHIP_CHANGED
}
current.map { it.id } != request.snapshot.memberContentIds -> TranslationSelectionError.MEMBERSHIP_CHANGED
request.snapshot.preparationSources?.let { it != current.map { content -> content.selectionSource() } } == true ->
TranslationSelectionError.SOURCE_CHANGED
else -> null
}
if (error != null) {
fail(request, error)
return null
}
return current
}
private fun fail(request: TranslationSelectionRequest, error: TranslationSelectionError) {
store.save(
request.copy(
status = TranslationSelectionStatus.FAILED,
errorCode = error,
preparationLeaseUntil = null,
preparationFence = request.preparationFence + 1,
updatedAt = now()
)
)
}
private fun AudioContent.selectionSource(): SelectionContentSource {
val source = toContentSourceSnapshot()
return SelectionContentSource(
requireNotNull(id),
source.sourceLanguage,
source.title,
source.detail,
source.tags,
source.selectionFingerprints()
)
}
private fun now(): LocalDateTime = nowProvider().truncatedTo(ChronoUnit.SECONDS)
}
@@ -0,0 +1,96 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionRequestSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.security.MessageDigest
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
import java.util.UUID
@Service
class TranslationSelectionRequestService(
private val store: TranslationSelectionStore,
private val sources: ContentTranslationSourceService,
transactionManager: PlatformTransactionManager,
private val candidates: TranslationCandidateStore,
private val nowProvider: () -> LocalDateTime = { LocalDateTime.now(ZoneOffset.UTC) }
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun create(adminId: Long, clientRequestId: UUID, scope: TranslationSelectionScope): TranslationSelectionRequest {
if (adminId <= 0 || scope.resourceId() <= 0) throw TranslationSelectionError.INVALID_REQUEST.exception()
val hash = MessageDigest.getInstance("SHA-256").digest(scope.canonicalBody().toByteArray(Charsets.UTF_8))
.joinToString("") { "%02x".format(it) }
fun replay(): TranslationSelectionRequest? = transaction.execute { store.findCreation(adminId, clientRequestId) }?.also {
if (it.bodyHash != hash) throw TranslationSelectionError.IDEMPOTENCY_CONFLICT.exception()
}
replay()?.let { return it }
try {
return requireNotNull(
transaction.execute {
val members = sources.lockScope(scope) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
val now = nowProvider().truncatedTo(ChronoUnit.SECONDS)
store.save(
TranslationSelectionRequest(
createdBy = adminId,
clientRequestId = clientRequestId,
bodyHash = hash,
scope = scope,
snapshot = SelectionRequestSnapshot(
memberContentIds = members.map { requireNotNull(it.id) }.sorted()
),
status = if (members.isEmpty()) {
TranslationSelectionStatus.FAILED
} else {
TranslationSelectionStatus.PREPARING
},
errorCode = if (members.isEmpty()) TranslationSelectionError.EMPTY_SCOPE else null,
createdAt = now
)
)
}
)
} catch (collision: DataIntegrityViolationException) {
// The failed insert transaction is already rolled back before reading the winning unique row.
return replay() ?: throw collision
}
}
@Transactional(readOnly = true)
fun get(requestId: Long): TranslationSelectionRequest =
store.find(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
@Transactional
fun cancel(requestId: Long): TranslationSelectionRequest {
val request = store.lock(requestId) ?: throw TranslationSelectionError.RESOURCE_NOT_FOUND.exception()
if (request.status == TranslationSelectionStatus.CANCELLED) return request
if (request.status.isTerminal()) throw TranslationSelectionError.REQUEST_CLOSED.exception()
val now = nowProvider().truncatedTo(ChronoUnit.SECONDS)
candidates.discard(requestId, now)
return store.save(
request.copy(
status = TranslationSelectionStatus.CANCELLED,
preparationLeaseUntil = null,
preparationFence = request.preparationFence + 1,
revision = request.revision + 1,
updatedAt = now
)
)
}
}
@@ -0,0 +1,169 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslateRequest
import kr.co.vividnext.sodalive.i18n.translation.TranslationCallControl
import kr.co.vividnext.sodalive.i18n.translation.TranslationCallStopReason
import kr.co.vividnext.sodalive.i18n.translation.TranslationProvider
import kr.co.vividnext.sodalive.i18n.translation.translationCallStop
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateClaim
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateFailure
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
@Service
class TranslationSelectionWorkerService(
private val requests: TranslationSelectionStore,
private val candidates: TranslationCandidateStore,
private val providers: List<TranslationProvider>,
transactionManager: PlatformTransactionManager,
private val nowProvider: () -> LocalDateTime = { LocalDateTime.now(ZoneOffset.UTC) }
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
isolationLevel = TransactionDefinition.ISOLATION_READ_COMMITTED
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun runNext(): Boolean {
val claim = claimNext() ?: return false
process(claim)
return true
}
fun claimNext(): TranslationCandidateClaim? = transaction.execute {
val now = now()
val requestId = candidates.nextRequest(now) ?: return@execute null
val request = requests.lock(requestId) ?: return@execute null
if (request.status != TranslationSelectionStatus.GENERATING) return@execute null
val candidate = candidates.lockNext(requestId, now) ?: return@execute null
if (candidate.attempt >= 2) {
val failed = candidates.save(
candidate.copy(
status = TranslationCandidateStatus.FAILED,
failureCode = TranslationCandidateFailure.EXECUTION_INTERRUPTED,
fence = candidate.fence + 1,
leaseUntil = null,
updatedAt = now,
terminalAt = now
)
)
candidates.completeLinked(failed)
finishIfReady(request)
return@execute null
}
val claimed = candidates.save(
candidate.copy(
status = TranslationCandidateStatus.RUNNING,
attempt = candidate.attempt + 1,
fence = candidate.fence + 1,
leaseUntil = now.plusSeconds(60),
updatedAt = now
)
)
TranslationCandidateClaim(claimed, request.revision)
}
fun authorize(claim: TranslationCandidateClaim): Boolean = transaction.execute {
val (_, candidate) = current(claim) ?: return@execute false
val now = now()
candidates.save(candidate.copy(leaseUntil = now.plusSeconds(60), updatedAt = now))
true
} == true
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun process(claim: TranslationCandidateClaim) {
val candidate = claim.candidate
val provider = providers.singleOrNull {
it.providerId.code == candidate.provider.id && it.providerVersion == candidate.provider.version
}
if (provider == null) {
publish(claim, null, TranslationCandidateFailure.PROVIDER_CHANGED)
return
}
var values: List<String>? = null
val failure = try {
val control = TranslationCallControl({ authorize(claim) })
control.beforeCall()
values = provider.translate(
TranslateRequest(
candidate.unit.inputValues,
candidate.unit.sourceLanguage,
candidate.targetLanguage,
candidate.unit.field == ContentSourceFieldKey.TAGS,
control
)
).translatedText
control.remainingTimeout()
when {
values.size != candidate.unit.inputValues.size || values.any { it.isBlank() } ->
TranslationCandidateFailure.INVALID_PROVIDER_RESULT
candidate.unit.field == ContentSourceFieldKey.TAGS && provider.providerId == LanguageProviderId.AWS &&
candidate.unit.inputValues.zip(values).any { (source, translated) ->
SourceTextNormalizer.hasSameCommaSeparatedText(source, translated)
} -> TranslationCandidateFailure.INVALID_PROVIDER_RESULT
else -> null
}
} catch (error: Exception) {
if (error.translationCallStop()?.reason == TranslationCallStopReason.OWNERSHIP_LOST) return
// Raw provider exceptions never cross the candidate persistence/API boundary.
TranslationCandidateFailure.PROVIDER_FAILED
}
publish(claim, if (failure == null) values else null, failure)
}
fun publish(claim: TranslationCandidateClaim, values: List<String>?, failure: TranslationCandidateFailure?): Boolean =
transaction.execute {
val (request, candidate) = current(claim) ?: return@execute false
val now = now()
val completed = candidates.save(
candidate.copy(
status = if (failure == null) TranslationCandidateStatus.SUCCEEDED else TranslationCandidateStatus.FAILED,
translatedValues = values,
failureCode = failure,
leaseUntil = null,
updatedAt = now,
terminalAt = now
)
)
candidates.completeLinked(completed)
finishIfReady(request)
true
} == true
private fun current(claim: TranslationCandidateClaim): Pair<TranslationSelectionRequest, TranslationCandidate>? {
val request = requests.lock(claim.candidate.requestId) ?: return null
if (request.status != TranslationSelectionStatus.GENERATING || request.revision != claim.generationRevision) return null
val candidate = candidates.lock(claim.candidate.candidateId) ?: return null
if (candidate.status != TranslationCandidateStatus.RUNNING || candidate.fence != claim.candidate.fence ||
candidate.leaseUntil?.isAfter(now()) != true
) {
return null
}
return request to candidate
}
private fun finishIfReady(request: TranslationSelectionRequest) {
val progress = candidates.progress(request.requestId)
if (progress.total == progress.terminal) {
requests.save(request.copy(status = TranslationSelectionStatus.READY, updatedAt = now()))
}
}
private fun now(): LocalDateTime = nowProvider().truncatedTo(ChronoUnit.SECONDS)
}
@@ -0,0 +1,65 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceField
import java.io.ByteArrayOutputStream
import java.io.DataOutputStream
import java.security.MessageDigest
enum class ContentSourceFieldKey(val key: String) {
TITLE("title"), DETAIL("detail"), TAGS("tags")
}
class ContentSourceSnapshot(
val sourceLanguage: String?,
val title: String,
val detail: String,
tags: List<String>
) {
val tags: List<String> = java.util.List.copyOf(tags)
val fields: List<TranslationSourceField> = java.util.List.of(
TranslationSourceField(ContentSourceFieldKey.TITLE.key, title),
TranslationSourceField(ContentSourceFieldKey.DETAIL.key, detail),
TranslationSourceField(ContentSourceFieldKey.TAGS.key, this.tags.joinToString(","))
)
val detectionQuery: String = listOf(title.trim(), detail.trim(), this.tags.joinToString(" ").trim())
.filter { it.isNotBlank() }.joinToString(" ")
fun fingerprint(field: ContentSourceFieldKey): String {
val values = when (field) {
ContentSourceFieldKey.TITLE -> listOf(title)
ContentSourceFieldKey.DETAIL -> listOf(detail)
ContentSourceFieldKey.TAGS -> tags
}
val bytes = ByteArrayOutputStream()
DataOutputStream(bytes).use { output ->
output.writeFrame("content-source-v1")
output.writeFrame(sourceLanguage)
output.writeFrame(field.key)
output.writeInt(values.size)
values.forEach { output.writeFrame(it) }
}
val hash = MessageDigest.getInstance("SHA-256").digest(bytes.toByteArray())
.joinToString("") { "%02x".format(it) }
return "v1:$hash"
}
override fun equals(other: Any?): Boolean = other is ContentSourceSnapshot &&
sourceLanguage == other.sourceLanguage && title == other.title && detail == other.detail && tags == other.tags
override fun hashCode(): Int {
var result = sourceLanguage?.hashCode() ?: 0
result = 31 * result + title.hashCode()
result = 31 * result + detail.hashCode()
return 31 * result + tags.hashCode()
}
private fun DataOutputStream.writeFrame(value: String?) {
if (value == null) {
writeInt(-1)
} else {
val bytes = value.toByteArray(Charsets.UTF_8)
writeInt(bytes.size)
write(bytes)
}
}
}
@@ -0,0 +1,26 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
import java.time.LocalDateTime
data class ApprovalProvider(val id: String, val version: String)
data class ApprovalProvenance(
val requestId: Long,
val candidateIds: List<Long>,
val providers: List<ApprovalProvider>,
val approvedBy: Long
)
data class ContentFieldApproval(
val field: ContentSourceFieldKey,
val sourceFingerprint: String,
val translatedText: String,
val provenance: ApprovalProvenance
)
data class ContentTranslationOverride(
val contentId: Long,
val locale: String,
val approval: ContentFieldApproval,
val approvedAt: LocalDateTime
)
@@ -0,0 +1,152 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
import java.util.regex.Pattern
class TitleGroupingAnalyzer {
fun analyze(inputs: List<TitleGroupingInput>): TitleGrouping {
require(inputs.map { it.contentId }.distinct().size == inputs.size) { "Duplicate content ID" }
val candidates = inputs.sortedBy { it.contentId }.groupBy { it.sourceLanguage }.values.flatMap { members ->
val texts = members.associate { it.contentId to GraphemeTitle(it.title) }
val repeated = mutableSetOf<String>()
members.forEachIndexed { index, left ->
members.drop(index + 1).forEach { right ->
scan(texts.getValue(left.contentId), texts.getValue(right.contentId), repeated)
}
}
repeated.mapNotNull { text ->
val occurrences = members.mapNotNull { member ->
texts.getValue(member.contentId).uniqueOccurrence(member.contentId, text)
}
if (occurrences.size < 2) null else Candidate(text, occurrences)
}
}.sortedWith { left, right ->
compareValues(right.savings, left.savings).takeIf { it != 0 }
?: compareValues(right.length, left.length).takeIf { it != 0 }
?: compareCodePoints(left.text, right.text).takeIf { it != 0 }
?: compareMemberIds(left.occurrences, right.occurrences)
}
val assigned = mutableSetOf<Long>()
val groups = mutableListOf<ReviewedTitleGroup>()
var partNumber = 0
candidates.forEach { seed ->
val memberIds = seed.occurrences.map { it.contentId }.filter { it !in assigned }
if (memberIds.size >= 2) {
val parts = mutableListOf<ReviewedSharedPart>()
candidates.forEach { candidate ->
val occurrences = candidate.occurrences.filter { it.contentId in memberIds }
if (occurrences.size == memberIds.size && occurrences.all { occurrence ->
parts.flatMap { it.occurrences }.none { existing -> existing.overlaps(occurrence) }
}
) {
parts.add(ReviewedSharedPart("p-${++partNumber}", occurrences))
}
}
groups.add(ReviewedTitleGroup("g-${groups.size + 1}", memberIds, parts))
assigned.addAll(memberIds)
}
}
return TitleGroupingReview(groups, inputs.map { it.contentId }.filter { it !in assigned }).validate(inputs)
}
// Scan matching diagonals without retaining a quadratic longest-common-substring matrix.
private fun scan(left: GraphemeTitle, right: GraphemeTitle, repeated: MutableSet<String>) {
for (diagonal in 1 - right.graphemes.size until left.graphemes.size) {
var i = maxOf(0, diagonal)
var j = maxOf(0, -diagonal)
while (i < left.graphemes.size && j < right.graphemes.size) {
if (left.graphemes[i] != right.graphemes[j]) {
i++
j++
continue
}
val initialI = i
val initialJ = j
while (i < left.graphemes.size && j < right.graphemes.size && left.graphemes[i] == right.graphemes[j]) {
i++
j++
}
var start = initialI
var end = i
while (start < end &&
(!left.lexicalBoundary(start) || !right.lexicalBoundary(initialJ + start - initialI))
) start++
while (end > start && (!left.lexicalBoundary(end) || !right.lexicalBoundary(initialJ + end - initialI))) end--
val text = left.substring(start, end)
if (text.codePoints().filter { Character.isLetter(it) }.count() >= 2) repeated.add(text)
}
}
}
private data class Candidate(val text: String, val occurrences: List<TitleOccurrence>) {
val length: Int = text.codePointCount(0, text.length)
val savings: Long = length.toLong() * (occurrences.size - 1)
}
private fun compareCodePoints(left: String, right: String): Int {
val a = left.codePoints().iterator()
val b = right.codePoints().iterator()
while (a.hasNext() && b.hasNext()) {
val comparison = a.nextInt().compareTo(b.nextInt())
if (comparison != 0) return comparison
}
return a.hasNext().compareTo(b.hasNext())
}
private fun compareMemberIds(left: List<TitleOccurrence>, right: List<TitleOccurrence>): Int {
left.zip(right).forEach { (a, b) ->
val comparison = a.contentId.compareTo(b.contentId)
if (comparison != 0) return comparison
}
return left.size.compareTo(right.size)
}
}
internal class GraphemeTitle(private val raw: String) {
val graphemes: List<String> = GRAPHEME.matcher(raw).results().map { it.group() }.toList()
private val charOffsets = IntArray(graphemes.size + 1)
val codePointOffsets = IntArray(graphemes.size + 1)
init {
graphemes.forEachIndexed { index, text ->
charOffsets[index + 1] = charOffsets[index] + text.length
codePointOffsets[index + 1] = codePointOffsets[index] + text.codePointCount(0, text.length)
}
}
fun substring(start: Int, end: Int): String = raw.substring(charOffsets[start], charOffsets[end])
fun slice(occurrence: TitleOccurrence): String {
val start = codePointOffsets.binarySearch(occurrence.startCodePoint)
val end = codePointOffsets.binarySearch(occurrence.endCodePoint)
require(start >= 0 && end > start) { "Range must be nonempty and follow grapheme boundaries" }
return substring(start, end)
}
fun lexicalBoundary(index: Int): Boolean = index == 0 || index == graphemes.size ||
!isWord(graphemes[index - 1]) || !isWord(graphemes[index])
fun uniqueOccurrence(contentId: Long, text: String): TitleOccurrence? {
var from = 0
var found: TitleOccurrence? = null
while (from <= raw.length - text.length) {
val position = raw.indexOf(text, from)
if (position < 0) break
val start = charOffsets.binarySearch(position)
val end = charOffsets.binarySearch(position + text.length)
if (start >= 0 && end >= 0 && lexicalBoundary(start) && lexicalBoundary(end)) {
if (found != null) return null
found = TitleOccurrence(contentId, codePointOffsets[start], codePointOffsets[end])
}
from = position + 1
}
return found
}
private fun isWord(text: String): Boolean = text.codePoints().anyMatch {
Character.isLetterOrDigit(it) || Character.getType(it) == Character.CONNECTOR_PUNCTUATION.toInt()
}
companion object {
private val GRAPHEME = Pattern.compile("\\X")
}
}
@@ -0,0 +1,38 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
import java.time.LocalDateTime
enum class TranslationCandidateStatus { PENDING, RUNNING, SUCCEEDED, FAILED, DISCARDED }
enum class TranslationCandidateFailure { PROVIDER_FAILED, PROVIDER_CHANGED, INVALID_PROVIDER_RESULT, EXECUTION_INTERRUPTED }
enum class TranslationUnitKind { FIELD, GROUP_COMMON, TITLE_RESIDUAL }
data class TranslationGenerationUnit(
val key: String,
val kind: TranslationUnitKind,
val sourceLanguage: String,
val inputValues: List<String>,
val contentId: Long? = null,
val field: ContentSourceFieldKey? = null,
val groupId: String? = null
)
data class TranslationCandidate(
val candidateId: Long = 0,
val requestId: Long,
val unit: TranslationGenerationUnit,
val provider: ApprovalProvider,
val targetLanguage: String,
val status: TranslationCandidateStatus = TranslationCandidateStatus.PENDING,
val translatedValues: List<String>? = null,
val failureCode: TranslationCandidateFailure? = null,
val attempt: Int = 0,
val leaseUntil: LocalDateTime? = null,
val fence: Long = 0,
val createdAt: LocalDateTime,
val updatedAt: LocalDateTime = createdAt,
val terminalAt: LocalDateTime? = null,
val linkedCandidateId: Long? = null
)
data class TranslationCandidateClaim(val candidate: TranslationCandidate, val generationRevision: Long)
data class SelectionCandidateProgress(val total: Int = 0, val terminal: Int = 0, val succeeded: Int = 0, val failed: Int = 0)
@@ -0,0 +1,152 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
data class TitleGroupingInput(val contentId: Long, val sourceLanguage: String, val title: String)
data class TitleOccurrence(val contentId: Long, val startCodePoint: Int, val endCodePoint: Int)
data class ReviewedSharedPart(val partId: String, val occurrences: List<TitleOccurrence>)
data class ReviewedTitleGroup(val groupId: String, val memberContentIds: List<Long>, val sharedParts: List<ReviewedSharedPart>)
data class TitleGroupingReview(val groups: List<ReviewedTitleGroup>, val individualContentIds: List<Long>) {
fun validate(inputs: List<TitleGroupingInput>): TitleGrouping {
val sources = inputs.associateBy { it.contentId }
require(sources.size == inputs.size) { "Duplicate content ID" }
val assigned = groups.flatMap { it.memberContentIds } + individualContentIds
require(assigned.size == sources.size && assigned.toSet() == sources.keys) { "Scope must be covered exactly once" }
require(groups.map { it.groupId }.distinct().size == groups.size && groups.all { it.groupId.isNotBlank() }) {
"Group IDs must be nonempty and unique"
}
val parts = groups.flatMap { it.sharedParts }
require(parts.map { it.partId }.distinct().size == parts.size && parts.all { it.partId.isNotBlank() }) {
"Part IDs must be nonempty and unique"
}
val titles = inputs.associate { it.contentId to GraphemeTitle(it.title) }
val validated = groups.map { group ->
val memberIds = group.memberContentIds.sorted()
require(memberIds.size >= 2 && group.sharedParts.isNotEmpty()) { "Group needs two members and a shared part" }
val languages = memberIds.map { sources.getValue(it).sourceLanguage }.distinct()
require(languages.size == 1) { "Group languages must match" }
val shared = group.sharedParts.map { part ->
require(part.occurrences.map { it.contentId }.sorted() == memberIds) {
"Part must cover every member exactly once"
}
val occurrences = part.occurrences.sortedBy { it.contentId }
val texts = occurrences.map { titles.getValue(it.contentId).slice(it) }
require(texts.distinct().size == 1) { "Shared raw text must match exactly" }
TitleSharedPart(part.partId, texts.first(), java.util.List.copyOf(occurrences))
}
memberIds.forEach { contentId ->
val ranges = shared.flatMap { it.occurrences }.filter { it.contentId == contentId }.sortedBy { it.startCodePoint }
require(ranges.zipWithNext().none { (left, right) -> left.overlaps(right) }) { "Shared parts overlap" }
}
TitleGroup(group.groupId, languages.single(), java.util.List.copyOf(memberIds), java.util.List.copyOf(shared))
}
val templates = validated.flatMap { group ->
group.memberContentIds.map { contentId -> template(sources.getValue(contentId), group, titles.getValue(contentId)) }
}.sortedBy { it.contentId }
return TitleGrouping(
java.util.List.copyOf(validated),
java.util.List.copyOf(individualContentIds.sorted()),
java.util.List.copyOf(templates)
)
}
private fun template(input: TitleGroupingInput, group: TitleGroup, title: GraphemeTitle): TitleTemplate {
val segments = mutableListOf<TitleSegment>()
var residualIndex = 0
var cursor = 0
val outerDelimiters = Regex("[\\p{javaWhitespace}\\p{Z}\\p{P}<>]+")
fun appendGap(endCodePoint: Int) {
val start = title.codePointOffsets.binarySearch(cursor)
val end = title.codePointOffsets.binarySearch(endCodePoint)
val hasLetters = (start until end).any { index ->
title.graphemes[index].codePoints().anyMatch { Character.isLetter(it) }
}
var residualStart = start
var residualEnd = end
if (hasLetters) {
while (residualStart < residualEnd && outerDelimiters.matches(title.graphemes[residualStart])) residualStart++
while (residualEnd > residualStart && outerDelimiters.matches(title.graphemes[residualEnd - 1])) residualEnd--
}
val boundaries = if (hasLetters) listOf(start, residualStart, residualEnd, end) else listOf(start, end)
boundaries.zipWithNext().filter { (from, to) -> from < to }.forEach { (from, to) ->
val translatable = hasLetters && from == residualStart && to == residualEnd
segments.add(
TitleSegment(
"s-${segments.size + 1}",
if (translatable) TitleSegmentKind.RESIDUAL else TitleSegmentKind.LITERAL,
title.codePointOffsets[from],
title.codePointOffsets[to],
title.substring(from, to),
null,
if (translatable) residualIndex++ else null
)
)
}
cursor = endCodePoint
}
val shared = group.sharedParts.mapIndexed { index, part ->
Triple(index, part, part.occurrences.single { it.contentId == input.contentId })
}.sortedBy { it.third.startCodePoint }
shared.forEach { (valueIndex, part, occurrence) ->
appendGap(occurrence.startCodePoint)
segments.add(
TitleSegment(
"s-${segments.size + 1}",
TitleSegmentKind.SHARED,
occurrence.startCodePoint,
occurrence.endCodePoint,
part.sourceText,
part.partId,
valueIndex
)
)
cursor = occurrence.endCodePoint
}
appendGap(title.codePointOffsets.last())
return TitleTemplate(
input.contentId,
group.groupId,
ContentSourceSnapshot(input.sourceLanguage, input.title, "", emptyList()).fingerprint(ContentSourceFieldKey.TITLE),
java.util.List.copyOf(segments)
)
}
}
data class TitleSharedPart(val partId: String, val sourceText: String, val occurrences: List<TitleOccurrence>)
data class TitleGroup(
val groupId: String,
val sourceLanguage: String,
val memberContentIds: List<Long>,
val sharedParts: List<TitleSharedPart>
)
data class TitleGrouping(val groups: List<TitleGroup>, val individualContentIds: List<Long>, val templates: List<TitleTemplate>)
enum class TitleSegmentKind { LITERAL, SHARED, RESIDUAL }
data class TitleSegment(
val segmentId: String,
val kind: TitleSegmentKind,
val startCodePoint: Int,
val endCodePoint: Int,
val sourceText: String,
val partId: String?,
val valueIndex: Int?
)
data class TitleTemplate(
val contentId: Long,
val groupId: String,
val sourceFingerprint: String,
val segments: List<TitleSegment>
) {
val residualInputs: List<String> get() = segments.filter { it.kind == TitleSegmentKind.RESIDUAL }.map { it.sourceText }
fun render(sharedValues: List<String>, residualValues: List<String>): String {
require(sharedValues.size == segments.count { it.kind == TitleSegmentKind.SHARED }) { "Shared value count differs" }
require(residualValues.size == residualInputs.size) { "Residual value count differs" }
return segments.joinToString("") { segment ->
when (segment.kind) {
TitleSegmentKind.LITERAL -> segment.sourceText
TitleSegmentKind.SHARED -> sharedValues[requireNotNull(segment.valueIndex)]
TitleSegmentKind.RESIDUAL -> residualValues[requireNotNull(segment.valueIndex)]
}
}
}
}
internal fun TitleOccurrence.overlaps(other: TitleOccurrence): Boolean = contentId == other.contentId &&
startCodePoint < other.endCodePoint && other.startCodePoint < endCodePoint
@@ -0,0 +1,138 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
import com.fasterxml.jackson.annotation.JsonSubTypes
import com.fasterxml.jackson.annotation.JsonTypeInfo
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionApplyReceipt
import java.time.LocalDateTime
import java.util.UUID
enum class TranslationSelectionStatus {
PREPARING, REVIEW_REQUIRED, READY_TO_GENERATE, GENERATING, READY, APPLIED, CANCELLED, FAILED;
fun isTerminal(): Boolean = this in setOf(APPLIED, CANCELLED, FAILED)
}
enum class TranslationSelectionError {
INVALID_REQUEST, RESOURCE_NOT_FOUND, EMPTY_SCOPE, UNSUPPORTED_SOURCE_LANGUAGE, LANGUAGE_DETECTION_FAILED,
PREPARATION_INTERRUPTED, INVALID_GROUPING, REVISION_CONFLICT, REQUEST_NOT_READY, REQUEST_CLOSED, REVIEW_REQUIRED,
SOURCE_CHANGED, MEMBERSHIP_CHANGED, IDEMPOTENCY_CONFLICT, CANDIDATE_NOT_SELECTABLE, INCOMPLETE_TITLE_GROUP;
fun exception(): SodaException = SodaException(
messageKey = when (this) {
RESOURCE_NOT_FOUND -> "translation.selection.not_found"
INVALID_GROUPING -> "translation.selection.invalid_grouping"
REVISION_CONFLICT -> "translation.selection.revision_conflict"
IDEMPOTENCY_CONFLICT -> "translation.selection.idempotency_conflict"
REQUEST_CLOSED -> "translation.selection.closed"
REQUEST_NOT_READY -> "translation.selection.not_ready"
CANDIDATE_NOT_SELECTABLE -> "translation.selection.candidate_not_selectable"
INCOMPLETE_TITLE_GROUP -> "translation.selection.incomplete_title_group"
SOURCE_CHANGED -> "translation.selection.source_changed"
MEMBERSHIP_CHANGED -> "translation.selection.membership_changed"
else -> "common.error.invalid_request"
},
errorProperty = name
)
}
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
@JsonSubTypes(
JsonSubTypes.Type(value = TranslationSelectionScope.Content::class, name = "CONTENT"),
JsonSubTypes.Type(value = TranslationSelectionScope.Series::class, name = "SERIES")
)
sealed class TranslationSelectionScope {
data class Content(val contentId: Long) : TranslationSelectionScope()
data class Series(val seriesId: Long) : TranslationSelectionScope()
fun resourceId(): Long = when (this) {
is Content -> contentId
is Series -> seriesId
}
fun canonicalBody(): String = when (this) {
is Content -> "v1:CONTENT:$contentId"
is Series -> "v1:SERIES:$seriesId"
}
}
// Only stored source fields are serialized; shared snapshot's derived getters are never persisted.
data class SelectionContentSource(
val contentId: Long,
val sourceLanguage: String?,
val title: String,
val detail: String,
val tags: List<String>,
val sourceFingerprints: SelectionFieldValues
) {
fun source(): ContentSourceSnapshot = ContentSourceSnapshot(sourceLanguage, title, detail, tags)
}
data class SelectionFieldValues(val title: String, val detail: String, val tags: String)
fun ContentSourceSnapshot.selectionFingerprints() = SelectionFieldValues(
fingerprint(ContentSourceFieldKey.TITLE),
fingerprint(ContentSourceFieldKey.DETAIL),
fingerprint(ContentSourceFieldKey.TAGS)
)
data class SelectionTitleTemplate(
val contentId: Long,
val groupId: String,
val sourceFingerprint: String,
val segments: List<TitleSegment>
) {
fun template(): TitleTemplate = TitleTemplate(contentId, groupId, sourceFingerprint, segments)
}
data class SelectionGroupingSnapshot(
val groups: List<TitleGroup>,
val individualContentIds: List<Long>,
val templates: List<SelectionTitleTemplate>
)
fun TitleGrouping.selectionSnapshot() = SelectionGroupingSnapshot(
groups,
individualContentIds,
templates.map { SelectionTitleTemplate(it.contentId, it.groupId, it.sourceFingerprint, it.segments) }
)
data class SelectionRequestSnapshot(
val version: Int = 1,
val memberContentIds: List<Long>,
val preparationSources: List<SelectionContentSource>? = null,
val contents: List<SelectionContentSource> = emptyList(),
val grouping: SelectionGroupingSnapshot? = null,
val reviewed: Boolean = false,
val providerManifest: List<ApprovalProvider> = emptyList(),
val targetLanguages: List<String> = emptyList(),
val generationUnits: List<TranslationGenerationUnit> = emptyList()
)
data class TranslationSelectionRequest(
val requestId: Long = 0,
val createdBy: Long,
val clientRequestId: UUID,
val bodyHash: String,
val scope: TranslationSelectionScope,
val status: TranslationSelectionStatus = TranslationSelectionStatus.PREPARING,
val revision: Long = 1,
val snapshot: SelectionRequestSnapshot,
val preparationAttempt: Int = 0,
val preparationLeaseUntil: LocalDateTime? = null,
val preparationFence: Long = 0,
val errorCode: TranslationSelectionError? = null,
val createdAt: LocalDateTime,
val updatedAt: LocalDateTime = createdAt,
val acceptedGenerateRevision: Long? = null,
val progress: SelectionCandidateProgress = SelectionCandidateProgress(),
val applyOperationId: UUID? = null,
val applyBodyHash: String? = null,
val applyReceipt: TranslationSelectionApplyReceipt? = null
)
data class TranslationPreparationClaim(val requestId: Long, val fence: Long, val sources: List<SelectionContentSource>)
fun List<SelectionContentSource>.groupingInputs(): List<TitleGroupingInput> = map {
TitleGroupingInput(it.contentId, requireNotNull(it.sourceLanguage), it.title)
}
@@ -0,0 +1,50 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.dto
import com.fasterxml.jackson.annotation.JsonSubTypes
import com.fasterxml.jackson.annotation.JsonTypeInfo
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import java.security.MessageDigest
import java.util.UUID
data class ApplyTranslationSelectionRequest(
val operationId: UUID,
val expectedRevision: Long,
val selections: List<TranslationSelectionChoice>
) {
fun canonicalHash(): String {
val mapper = jacksonObjectMapper()
val choices = selections.map { choice ->
when (choice) {
is TranslationSelectionChoice.Field -> choice
is TranslationSelectionChoice.TitleGroup -> choice.copy(
residualChoices = choice.residualChoices.sortedBy { it.contentId }
)
}
}.sortedBy { mapper.writeValueAsString(it) }
val canonical = mapper.writeValueAsBytes(copy(selections = choices))
return MessageDigest.getInstance("SHA-256").digest(canonical).joinToString("") { "%02x".format(it) }
}
}
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "kind")
@JsonSubTypes(
JsonSubTypes.Type(value = TranslationSelectionChoice.Field::class, name = "FIELD"),
JsonSubTypes.Type(value = TranslationSelectionChoice.TitleGroup::class, name = "TITLE_GROUP")
)
sealed class TranslationSelectionChoice {
data class Field(
val contentId: Long,
val field: TranslationSelectionField,
val targetLanguage: String,
val candidateId: Long
) : TranslationSelectionChoice()
data class TitleGroup(
val groupId: String,
val targetLanguage: String,
val commonCandidateId: Long,
val residualChoices: List<TranslationSelectionResidualChoice>
) : TranslationSelectionChoice()
}
data class TranslationSelectionResidualChoice(val contentId: Long, val candidateId: Long?)
@@ -0,0 +1,40 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.dto
import com.fasterxml.jackson.annotation.JsonInclude
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateFailure
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationUnitKind
data class GenerateTranslationSelectionRequest(val expectedRevision: Long)
data class TranslationCandidatesResponse(val items: List<TranslationCandidateResponse>, val nextAfterCandidateId: Long?)
data class TranslationCandidateResponse(
val candidateId: Long,
val unit: TranslationCandidateUnitResponse,
val provider: ApprovalProvider,
val targetLanguage: String,
val inputValues: List<String>,
val status: TranslationCandidateStatus,
val translatedValues: List<String>?,
val failureCode: TranslationCandidateFailure?
)
@JsonInclude(JsonInclude.Include.NON_NULL)
data class TranslationCandidateUnitResponse(
val kind: TranslationUnitKind,
val contentId: Long?,
val field: String?,
val groupId: String?
)
fun TranslationCandidate.response() = TranslationCandidateResponse(
candidateId,
TranslationCandidateUnitResponse(unit.kind, unit.contentId, unit.field?.key, unit.groupId),
provider,
targetLanguage,
unit.inputValues,
status,
translatedValues,
failureCode
)
@@ -0,0 +1,13 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.dto
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ReviewedTitleGroup
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import java.util.UUID
data class CreateTranslationSelectionRequest(val clientRequestId: UUID, val scope: TranslationSelectionScope)
data class ReviewTranslationSelectionGroupingRequest(
val expectedRevision: Long,
val groups: List<ReviewedTitleGroup>,
val individualContentIds: List<Long>
)
@@ -0,0 +1,112 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.dto
import com.fasterxml.jackson.annotation.JsonInclude
import com.fasterxml.jackson.annotation.JsonValue
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionFieldValues
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionTitleTemplate
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TitleGroup
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionError
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import java.time.Instant
import java.time.ZoneOffset
import java.util.UUID
data class TranslationSelectionRequestResponse(
val requestId: Long,
val scope: TranslationSelectionScope,
val status: TranslationSelectionStatus,
val revision: Long,
val createdAt: Instant,
val providerManifest: List<ApprovalProvider>,
val targetLanguages: List<String>,
val contentCount: Int,
val progress: TranslationSelectionProgress,
val errorCode: TranslationSelectionError?,
val applyReceipt: TranslationSelectionApplyReceipt?
)
data class TranslationSelectionProgress(val total: Int = 0, val terminal: Int = 0, val succeeded: Int = 0, val failed: Int = 0)
data class TranslationSelectionApplyReceipt(
val requestId: Long,
val operationId: UUID,
val status: TranslationSelectionStatus,
val appliedAt: Instant,
val appliedFields: List<TranslationSelectionAppliedField>,
val discardedCandidateCount: Int
)
data class TranslationSelectionAppliedField(
val contentId: Long,
val field: TranslationSelectionField,
val targetLanguage: String,
val translatedValue: String,
val candidateIds: List<Long>,
val providers: List<ApprovalProvider>
)
fun TranslationSelectionRequest.response() = TranslationSelectionRequestResponse(
requestId, scope, status, revision, createdAt.toInstant(ZoneOffset.UTC), snapshot.providerManifest,
snapshot.targetLanguages, snapshot.contents.size,
TranslationSelectionProgress(progress.total, progress.terminal, progress.succeeded, progress.failed), errorCode, applyReceipt
)
enum class TranslationSelectionField(@get:JsonValue val key: String) { TITLE("title"), DETAIL("detail"), TAGS("tags") }
enum class TranslationSelectionApprovalOrigin { ADMIN, UNKNOWN }
enum class TitleIndexUnit { UNICODE_CODE_POINT }
data class TranslationSelectionGroupingResponse(
val requestId: Long,
val revision: Long,
val reviewed: Boolean,
val groups: List<TitleGroup>,
val individualContentIds: List<Long>,
val templates: List<SelectionTitleTemplate>,
val indexUnit: TitleIndexUnit = TitleIndexUnit.UNICODE_CODE_POINT
)
data class TranslationSelectionContentsResponse(
val items: List<TranslationSelectionContentResponse>,
val nextAfterContentId: Long?
)
data class TranslationSelectionContentResponse(
val contentId: Long,
val active: Boolean,
val eligible: Boolean,
val sourceLanguage: String,
val sourceFields: SelectionFieldValues,
val sourceFingerprints: SelectionFieldValues,
val currentSourceFingerprints: SelectionFieldValues?,
val emptyFields: List<TranslationSelectionField>,
val currentTranslations: List<TranslationSelectionCurrentTranslation>
)
data class TranslationSelectionCurrentTranslation(
val targetLanguage: String,
val fields: SelectionFieldValues,
val approvalOrigins: SelectionApprovalOrigins,
val approvalProvenance: SelectionApprovalProvenances
)
data class SelectionApprovalOrigins(
val title: TranslationSelectionApprovalOrigin,
val detail: TranslationSelectionApprovalOrigin,
val tags: TranslationSelectionApprovalOrigin
)
@JsonInclude(JsonInclude.Include.NON_NULL)
data class SelectionApprovalProvenances(
val title: TranslationSelectionApprovalProvenance?,
val detail: TranslationSelectionApprovalProvenance?,
val tags: TranslationSelectionApprovalProvenance?
)
data class TranslationSelectionApprovalProvenance(
val requestId: Long,
val candidateIds: List<Long>,
val providers: List<ApprovalProvider>,
val approvedBy: Long,
val approvedAt: Instant
)
@@ -0,0 +1,10 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.port
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentTranslationOverride
interface ContentTranslationOverrideStore {
fun findByContentId(contentId: Long): List<ContentTranslationOverride>
fun save(override: ContentTranslationOverride)
fun deleteFields(contentId: Long, fields: Set<ContentSourceFieldKey>, locale: String? = null)
}
@@ -0,0 +1,18 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.port
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.SelectionCandidateProgress
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import java.time.LocalDateTime
interface TranslationCandidateStore {
fun save(candidate: TranslationCandidate): TranslationCandidate
fun nextRequest(now: LocalDateTime): Long?
fun lockNext(requestId: Long, now: LocalDateTime): TranslationCandidate?
fun lock(candidateId: Long): TranslationCandidate?
fun find(candidateId: Long): TranslationCandidate?
fun page(requestId: Long, afterId: Long, limit: Int): List<TranslationCandidate>
fun progress(requestId: Long): SelectionCandidateProgress
fun completeLinked(source: TranslationCandidate)
fun discard(requestId: Long, now: LocalDateTime)
fun discardUnselected(requestId: Long, selectedIds: Set<Long>, now: LocalDateTime): Int
}
@@ -0,0 +1,13 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.port
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import java.time.LocalDateTime
import java.util.UUID
interface TranslationSelectionStore {
fun find(requestId: Long): TranslationSelectionRequest?
fun findCreation(adminId: Long, clientRequestId: UUID): TranslationSelectionRequest?
fun lock(requestId: Long): TranslationSelectionRequest?
fun nextPreparation(now: LocalDateTime): TranslationSelectionRequest?
fun save(request: TranslationSelectionRequest): TranslationSelectionRequest
}
@@ -25,7 +25,7 @@ import javax.persistence.EntityManager
properties = [
"cloud.aws.cloud-front.host=https://cdn.test",
"spring.datasource.url=jdbc:h2:mem:admin-chat-banner-controller-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureMockMvc
@@ -15,7 +15,7 @@ import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.context.ApplicationEventPublisher
import org.springframework.transaction.PlatformTransactionManager
import java.util.Optional
class AdminContentServiceTest {
@@ -44,7 +44,10 @@ class AdminContentServiceTest {
contentMainTabRepository = contentMainTabRepository,
objectMapper = jacksonObjectMapper(),
s3Uploader = s3Uploader,
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java),
sourceInvalidation = Mockito.mock(
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class.java
),
transactionManager = Mockito.mock(PlatformTransactionManager::class.java),
bucket = "test-bucket"
)
}
@@ -47,7 +47,7 @@ import javax.persistence.EntityManager
"cloud.aws.cloud-front.host=https://cdn.test",
"cloud.aws.s3.bucket=test-bucket",
"spring.datasource.url=jdbc:h2:mem:admin-content-banner-controller-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureMockMvc
@@ -26,7 +26,7 @@ import javax.persistence.EntityManager
properties = [
"cloud.aws.cloud-front.host=https://cdn.test",
"spring.datasource.url=jdbc:h2:mem:admin-series-banner-controller-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureMockMvc
@@ -38,7 +38,7 @@ import java.time.LocalDateTime
"cloud.aws.cloud-front.host=https://cdn.test",
"cloud.aws.s3.bucket=test-bucket",
"spring.datasource.url=jdbc:h2:mem:admin-event-banner-controller-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureMockMvc
@@ -25,7 +25,7 @@ import javax.persistence.EntityManager
properties = [
"cloud.aws.cloud-front.host=https://cdn.test",
"spring.datasource.url=jdbc:h2:mem:admin-live-controller-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureMockMvc
@@ -21,7 +21,7 @@ import javax.persistence.EntityManager
properties = [
"cloud.aws.cloud-front.host=https://cdn.test",
"spring.datasource.url=jdbc:h2:mem:admin-live-service-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@@ -58,7 +58,7 @@ import javax.persistence.EntityManager
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:charge-controller-http;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE",
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE",
"jwt.secret=MDEyMzQ1Njc4OWFiY2RlZjAxMjM0NTY3ODlhYmNkZWYwMTIzNDU2Nzg5YWJjZGVmMDEyMzQ1Njc4OWFiY2RlZg==",
"apple.iap-verify-url=https://apple.invalid/verifyReceipt",
"apple.iap-verify-sandbox-url=https://apple-sandbox.invalid/verifyReceipt",
@@ -58,7 +58,7 @@ import javax.persistence.EntityManager
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:charge-service-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE",
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE",
"apple.iap-verify-url=https://apple.invalid/verifyReceipt",
"apple.iap-verify-sandbox-url=https://apple-sandbox.invalid/verifyReceipt",
"payverse.host=https://payverse.invalid",
@@ -21,7 +21,7 @@ import javax.persistence.EntityManager
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:can-coupon-service-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@@ -23,7 +23,7 @@ import javax.persistence.EntityManager
properties = [
"cloud.aws.cloud-front.host=https://cdn.test",
"spring.datasource.url=jdbc:h2:mem:chat-banner-service-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@@ -20,6 +20,8 @@ import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorker
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemory
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceField
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import org.junit.jupiter.api.Assertions.assertEquals
@@ -69,6 +71,7 @@ class AudioContentDetailTranslationHttpIntegrationTest @Autowired constructor(
private val jdbc: JdbcTemplate,
private val worker: TranslationJobWorker,
private val scheduler: ResourceTranslationJobScheduler,
private val sourceExtractor: TranslationSourceExtractor,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
@@ -133,7 +136,45 @@ class AudioContentDetailTranslationHttpIntegrationTest @Autowired constructor(
assertEquals("ko", response.path("languageCode").textValue())
assertEquals("ko", transaction.execute { entityManager.find(AudioContent::class.java, fixture.first).languageCode })
assertEquals(listOf("원문 제목 원문 설명 #힐링"), provider.detectionQueries)
assertEquals(0L, jobs.count())
assertEquals(6L, jobs.count())
assertEquals(setOf("en", "ja"), jobs.findAll().map { it.targetLanguage }.toSet())
}
@Test
@DisplayName("상세와 추출기는 연관 ID 순서의 활성 태그와 같은 원문을 사용하고 메모리 정규화를 유지한다")
fun shouldShareOrderedActiveSourceAcrossExtractorAndDetail() {
val fixture = fixture(null, detail = "\t원문 설명 \n")
transaction.executeWithoutResult {
val content = entityManager.find(AudioContent::class.java, fixture.first)
content.title = " 원문 제목 \t"
val tag = HashTag(" #차분")
entityManager.persist(tag)
entityManager.persist(
AudioContentHashTag().apply {
audioContent = content
hashTag = tag
}
)
}
val response = detail(fixture)
val extracted = transaction.execute {
entityManager.find(AudioContent::class.java, fixture.first).audioContentHashTags.reverse()
sourceExtractor.extract(LanguageTranslationTargetType.CONTENT, fixture.first)
}
assertTranslation(response, "English title", "English detail", "#Healing, #Calm")
assertEquals(listOf("원문 제목 원문 설명 #힐링 #차분"), provider.detectionQueries)
assertEquals(
listOf(
TranslationSourceField("title", " 원문 제목 \t"),
TranslationSourceField("detail", "\t원문 설명 \n"),
TranslationSourceField("tags", "#힐링, #차분")
),
extracted?.fields
)
assertEquals(setOf("원문 제목", "원문 설명", "#힐링, #차분"), memories.findAll().map { it.sourceText }.toSet())
memories.findAll().forEach { assertEquals(SourceTextNormalizer.hash(it.sourceText), it.sourceHash) }
}
@Test
@@ -125,6 +125,9 @@ class AudioContentServiceTest {
homeFollowingNewsPublishService = homeFollowingNewsPublishService,
memberContentPreferenceService = memberContentPreferenceService,
subtitleJobService = subtitleJobService,
sourceInvalidation = Mockito.mock(
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class.java
),
transactionManager = Mockito.mock(PlatformTransactionManager::class.java),
audioContentBucket = "audio-bucket",
coverImageBucket = "cover-bucket",
@@ -29,6 +29,8 @@ import kr.co.vividnext.sodalive.member.MemberAdapter
import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.member.contentpreference.ViewerContentPreference
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import kr.co.vividnext.sodalive.v2.creatorname.application.CreatorLocalizedNameService
import kr.co.vividnext.sodalive.v2.home.following.application.HomeFollowingNewsPublishService
@@ -70,7 +72,11 @@ import javax.servlet.http.HttpServletResponse
TranslationReadModelMaterializer::class, LanguageDetectionCacheService::class,
AudioContentDetailTranslationService::class, TranslationMemoryService::class, TranslationJobWorker::class,
LanguageDetectListener::class, ContentSeriesController::class, ContentSeriesService::class,
ContentSeriesDetailTranslationService::class
ContentSeriesDetailTranslationService::class,
ContentTranslationWriteService::class,
JpaContentTranslationOverrideStore::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class
)
@MockBean(
classes = [
@@ -86,9 +86,13 @@ import javax.persistence.EntityManager
QueryDslConfig::class,
AudioContentThemeQueryRepository::class,
LanguageDetectListener::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class,
CreatorCommunityTranslationService::class,
TranslationSourceExtractor::class,
TranslationReadModelMaterializer::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
TranslationCoordinator::class,
PapagoTranslationService::class,
ResourceTranslationJobScheduler::class,
@@ -691,9 +695,10 @@ class CreatorCommunityLanguageDetectTest @Autowired constructor(
@Bean
@Primary
fun languageDetectionCacheService(
languageDetectionResultRepository: LanguageDetectionResultRepository
languageDetectionResultRepository: LanguageDetectionResultRepository,
transactionManager: PlatformTransactionManager
): ControlledLanguageDetectionCacheService {
return ControlledLanguageDetectionCacheService(languageDetectionResultRepository)
return ControlledLanguageDetectionCacheService(languageDetectionResultRepository, transactionManager)
}
@Bean
@@ -732,14 +737,16 @@ class CreatorCommunityLanguageDetectTest @Autowired constructor(
}
class ControlledLanguageDetectionCacheService(
languageDetectionResultRepository: LanguageDetectionResultRepository
languageDetectionResultRepository: LanguageDetectionResultRepository,
transactionManager: PlatformTransactionManager
) : LanguageDetectionCacheService(
languageDetectionResultRepository,
listOf(object : LanguageDetectionProvider {
override val providerId = LanguageProviderId.PAPAGO
override fun detect(query: String): String? = null
}),
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO))
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)),
transactionManager
) {
val detections = ConcurrentHashMap<String, String>()
val queries = ConcurrentLinkedQueue<String>()
@@ -79,9 +79,13 @@ import java.util.concurrent.atomic.AtomicInteger
PapagoTranslationService::class,
TranslationCoordinator::class,
LanguageDetectListener::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class,
CreatorCommunityTranslationService::class,
TranslationSourceExtractor::class,
TranslationReadModelMaterializer::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class
)
@@ -9,6 +9,9 @@ import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.support.SimpleTransactionStatus
class LanguageDetectionCacheServiceTest {
@Test
@@ -111,7 +114,11 @@ class LanguageDetectionCacheServiceTest {
return LanguageDetectionCacheService(
repository,
listOf(provider),
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO))
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)),
Mockito.mock(PlatformTransactionManager::class.java).also {
Mockito.`when`(it.getTransaction(Mockito.any(TransactionDefinition::class.java)))
.thenReturn(SimpleTransactionStatus())
}
)
}
}
@@ -55,6 +55,10 @@ import javax.persistence.EntityManager
QueryDslConfig::class,
AudioContentThemeQueryRepository::class,
LanguageDetectListener::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class,
TranslationSourceExtractor::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class,
@@ -137,7 +141,8 @@ class MetadataLanguageDetectTransactionTest @Autowired constructor(
}
private fun prepareDetection(target: MetadataTarget): LanguageDetectEvent {
Mockito.`when`(detectionCache.detectWithCache("원문 제목"))
val query = if (target == MetadataTarget.CONTENT) "원문 제목 원문 설명" else "원문 제목"
Mockito.`when`(detectionCache.detectWithCache(query))
.thenReturn(DetectedLanguage("ko", LanguageProviderId.PAPAGO))
val id = transaction.execute {
val owner = persist(Member(password = "password", nickname = "metadata-owner", role = MemberRole.CREATOR))
@@ -166,7 +171,7 @@ class MetadataLanguageDetectTransactionTest @Autowired constructor(
}
requireNotNull(persist(metadata).id)
}!!
return LanguageDetectEvent(id, "원문 제목", LanguageDetectTargetType.valueOf(target.name))
return LanguageDetectEvent(id, query, LanguageDetectTargetType.valueOf(target.name))
}
private fun <T : BaseEntity> persist(entity: T): T {
@@ -31,7 +31,7 @@ import java.time.LocalDateTime
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
properties = [
"spring.datasource.url=jdbc:h2:mem:notice-home-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@Import(AudioContentMainTabHomeServiceIntegrationTest.TimeConfiguration::class)
@@ -6,13 +6,13 @@ import kr.co.vividnext.sodalive.i18n.Lang
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.data.domain.PageRequest
import org.springframework.test.annotation.DirtiesContext
import org.springframework.test.context.ContextConfiguration
import org.springframework.transaction.support.TransactionTemplate
import javax.persistence.EntityManager
@@ -21,16 +21,24 @@ import javax.persistence.EntityManager
properties = [
"cloud.aws.cloud-front.host=https://cdn.test",
"spring.datasource.url=jdbc:h2:mem:series-banner-service-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD)
class ContentSeriesBannerServiceIntegrationTest @Autowired constructor(
private val service: ContentSeriesBannerService,
private val entityManager: EntityManager,
private val transactionTemplate: TransactionTemplate
) {
@AfterEach
fun removeFixtures() {
transactionTemplate.executeWithoutResult {
listOf("series_banner", "series", "series_genre", "member").forEach { table ->
entityManager.createNativeQuery("delete from $table").executeUpdate()
}
}
}
@Test
@DisplayName("OSIV off 환경에서 관리자 시리즈 배너 목록 응답 생성 시 lazy 초기화 예외가 발생하지 않는다")
fun shouldCreateAdminSeriesBannerListResponseWhenOpenInViewIsDisabled() {
@@ -19,7 +19,7 @@ import org.springframework.test.context.ContextConfiguration
"deployment.artifact-version=1.2.3-20260914",
"deployment.config-commit=1a2b3c4d5e6f708192a3b4c5d6e7f8091a2b3c4d",
"spring.datasource.url=jdbc:h2:mem:deployment-endpoint-injected-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@@ -20,7 +20,7 @@ import org.springframework.test.context.ContextConfiguration
properties = [
"management.server.port=0",
"spring.datasource.url=jdbc:h2:mem:deployment-endpoint-integration;" +
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE"
"MODE=MySQL;DATABASE_TO_UPPER=false;NON_KEYWORDS=VALUE;DB_CLOSE_DELAY=0;DB_CLOSE_ON_EXIT=FALSE"
]
)
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])

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