From 5ab1b4182cb6f528be925ab2dd429f873bd82b9f Mon Sep 17 00:00:00 2001 From: DongHyeonka Date: Sat, 7 Nov 2026 15:14:21 +0900 Subject: [PATCH] =?UTF-8?q?test(messaging):=20=EB=8C=80=EA=B8=B0=20?= =?UTF-8?q?=ED=97=88=EA=B0=80=20=ED=85=8C=EC=8A=A4=ED=8A=B8=EA=B0=80=20?= =?UTF-8?q?=EC=8B=A4=ED=96=89=20=EC=88=9C=EC=84=9C=EC=97=90=20=EB=94=B0?= =?UTF-8?q?=EB=9D=BC=20=EA=B0=88=EB=A6=AC=EC=A7=80=20=EC=95=8A=EA=B2=8C=20?= =?UTF-8?q?=ED=95=9C=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 문제: `MessagingAdmissionControllerTest.aWaitingCallerIsAdmittedOnceAPermitIsReturned`가 desktop 부하가 높을 때 가끔 실패한다(구조 정리 게이트에서 부하 7에 한 번, 이번에 부하 24~27에서 20번 중 한 번). 원인: 이 테스트는 대상 하나(`order.created`)로 허가 하나를 쥔 뒤, 같은 대상으로 대기자를 띄우고 곧바로 허가를 돌려준다. 그런데 대상별 상한(2인자 생성자에서는 프로세스 상한과 같은 1)이 나중에 더해지면서 같은 대상의 두 번째 호출은 프로세스 허가를 기다리지 않고 바로 `DESTINATION_IN_FLIGHT_LIMIT_EXCEEDED`로 거절된다. 그래서 테스트는 main 스레드의 `complete`가 대기자의 `admit`보다 먼저 돌 때만 통과한다(그때는 대기자가 기다릴 일이 없다). 부하가 높아 대기자가 먼저 돌면 거절되고 in-flight가 0이 되어 실패한다. 테스트 이름이 말하는 "기다리던 호출이 허가를 받는다"는 어느 쪽에서도 시험되지 않았다. 고친 방법: - 대기자를 다른 대상으로 보내 프로세스 허가만 다투게 한다. - 대기자가 실제로 limiter의 bounded wait에 들어가(TIMED_WAITING) 줄을 선 뒤에 허가를 돌려준다. 순서를 테스트가 정하므로 스레드 일정에 기대지 않는다. - 대기자의 거절을 잡아 단언한다(전에는 스레드 밖으로 사라졌다). - 대기 상한을 2초에서 30초로 늘린다. 부하가 높을 때 상한이 먼저 끝나 생기는 다른 갈림을 막는다. 대기자는 허가를 받는 즉시 끝나므로 평소 시간은 같다. 버린 대안: 같은 대상을 두고 3인자 생성자로 대상별 상한을 2로 주기. 그러면 대상별 상한 1·프로세스 상한 1 조합(2인자 생성자 기본)의 동작을 시험에서 숨긴다. 그 동작 자체를 바꾸는 것은 이 변경의 범위가 아니다. 위험·한계: 2인자 생성자 Javadoc은 "only ceiling is the process-wide one"이라 하지만 한 대상이 프로세스 허가를 모두 쥐면 같은 대상의 호출은 기다리지 않고 바로 거절된다. 운영 조립(`MessagingPublishConfiguration`)은 3인자 생성자로 대상별 상한(기본 64)을 따로 주므로 영향이 없다. 문서와 동작 중 무엇을 맞출지는 별도로 남긴다. 검증(desktop, `--no-build-cache`): - RED: 새 테스트 모양에 대기자를 같은 대상으로 두면 매번 실패한다. 메시지 "the waiter must be queued on the permit before it is returned (refused: MessageBackpressureException: order.created already holds its 1 in-flight publishes ...) expected: TIMED_WAITING but was: TERMINATED". - GREEN: `:messaging:messaging-policy:check :messaging:messaging-policy:testQualityCheck` rc=0, 테스트 43 실패 0. - 부하: busy loop 24개(12코어)를 건 채 이 클래스를 `--rerun`으로 20번 연속 돌렸다. 고친 트리 20/20 통과(1분 부하 8→24). 같은 부하에서 고치기 전 트리는 20번 중 1번 실패(8번째, "expected: 1 but was: 0", 대기자가 위 거절을 받음). 로그 desktop `~/i1-layout-docs-logs/flaky/`. --- .../MessagingAdmissionControllerTest.java | 44 +++++++++++++++++-- 1 file changed, 40 insertions(+), 4 deletions(-) diff --git a/src/platforms/messaging/messaging-policy/src/test/java/dev/caskeleton/messaging/policy/MessagingAdmissionControllerTest.java b/src/platforms/messaging/messaging-policy/src/test/java/dev/caskeleton/messaging/policy/MessagingAdmissionControllerTest.java index 93c78201..2306d76e 100644 --- a/src/platforms/messaging/messaging-policy/src/test/java/dev/caskeleton/messaging/policy/MessagingAdmissionControllerTest.java +++ b/src/platforms/messaging/messaging-policy/src/test/java/dev/caskeleton/messaging/policy/MessagingAdmissionControllerTest.java @@ -7,11 +7,14 @@ import dev.caskeleton.messaging.api.error.MessageBackpressureException; import dev.caskeleton.messaging.api.error.MessageTooLargeException; import java.time.Duration; import java.util.List; +import java.util.concurrent.atomic.AtomicReference; import org.junit.jupiter.api.Test; class MessagingAdmissionControllerTest { private static final String DESTINATION = "order.created"; + private static final String OTHER_DESTINATION = "invoice.issued"; + private static final Duration WAITER_BOUND = Duration.ofSeconds(30); private static MessagingAdmissionController controller(int limit) { return new MessagingAdmissionController( @@ -182,16 +185,49 @@ class MessagingAdmissionControllerTest { void aWaitingCallerIsAdmittedOnceAPermitIsReturned() throws InterruptedException { MessagingAdmissionController controller = new MessagingAdmissionController( - new PayloadLimitGuard(PayloadPolicy.defaults()), - new InFlightLimiter(1, Duration.ofSeconds(2))); + new PayloadLimitGuard(PayloadPolicy.defaults()), new InFlightLimiter(1, WAITER_BOUND)); controller.admit(DESTINATION, 100); + AtomicReference refused = new AtomicReference<>(); + // Another destination, so only the process-wide permit is contested. A second publish to + // DESTINATION is refused at once by its own ceiling (equal to the process limit here) and + // never waits. + Thread waiter = + new Thread( + () -> { + try { + controller.admit(OTHER_DESTINATION, 100); + } catch (RuntimeException refusal) { + refused.set(refusal); + } + }); - Thread waiter = new Thread(() -> controller.admit(DESTINATION, 100)); waiter.start(); + awaitQueuedOnAPermit(waiter, refused); controller.complete(DESTINATION); - waiter.join(Duration.ofSeconds(5).toMillis()); + waiter.join(WAITER_BOUND.toMillis()); + assertThat(refused.get()).as("the waiter was refused instead of admitted").isNull(); assertThat(waiter.isAlive()).isFalse(); assertThat(controller.inFlight()).isEqualTo(1); + assertThat(controller.inFlight(OTHER_DESTINATION)).isEqualTo(1); + } + + /** + * Waits until {@code waiter} is parked in the limiter's bounded wait, so the permit is returned + * to a caller that is already queued rather than to one that has not arrived yet. + */ + private static void awaitQueuedOnAPermit(Thread waiter, AtomicReference refused) + throws InterruptedException { + long deadline = System.nanoTime() + WAITER_BOUND.toNanos(); + while (waiter.getState() != Thread.State.TIMED_WAITING + && waiter.isAlive() + && System.nanoTime() < deadline) { + Thread.sleep(1); + } + assertThat(waiter.getState()) + .as( + "the waiter must be queued on the permit before it is returned (refused: %s)", + refused.get()) + .isEqualTo(Thread.State.TIMED_WAITING); } }