From 47c598a61c73e470c63bcb9ceebac6b2b13ae9bf Mon Sep 17 00:00:00 2001 From: kric_jspark Date: Wed, 4 Nov 2026 17:18:38 +0900 Subject: [PATCH] =?UTF-8?q?261104=5F02=5FHOT:=20=ED=8A=B8=EB=9E=9C?= =?UTF-8?q?=EC=A0=9D=EC=85=98=20=EB=88=84=EC=88=98=20=EA=B4=80=EB=A0=A8=20?= =?UTF-8?q?=EA=B8=B4=EA=B8=89=20=EC=A1=B0=EC=B9=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../kart/server/config/KartMyBatisConfig.java | 9 ++ .../service/DerivedManagementService.java | 8 +- .../derived/DerivedRecalculationGuard.java | 86 +++++++++++++++++++ src/main/resources/application.yml | 3 + 4 files changed, 104 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java diff --git a/src/main/java/com/kri/kart/server/config/KartMyBatisConfig.java b/src/main/java/com/kri/kart/server/config/KartMyBatisConfig.java index d3b5c21..6d93181 100644 --- a/src/main/java/com/kri/kart/server/config/KartMyBatisConfig.java +++ b/src/main/java/com/kri/kart/server/config/KartMyBatisConfig.java @@ -7,6 +7,7 @@ import org.apache.ibatis.session.SqlSessionFactory; import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.SqlSessionTemplate; import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; @@ -19,6 +20,13 @@ import org.springframework.jdbc.datasource.DataSourceTransactionManager; @EnableConfigurationProperties(KartDatabaseProperties.class) @ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true") public class KartMyBatisConfig { + private final long leakDetectionThreshold; + + public KartMyBatisConfig( + @Value("${spring.datasource.hikari.leak-detection-threshold:0}") long leakDetectionThreshold) { + this.leakDetectionThreshold = leakDetectionThreshold; + } + @Bean(destroyMethod = "close") public HikariDataSource konDataSource(KartDatabaseProperties properties, Validator validator) { return dataSource("kon", properties.getKon(), validator); @@ -53,6 +61,7 @@ public class KartMyBatisConfig { dataSource.setMaximumPoolSize(source.getMaximumPoolSize()); dataSource.setMinimumIdle(0); dataSource.setConnectionTimeout(10000); + dataSource.setLeakDetectionThreshold(leakDetectionThreshold); dataSource.setInitializationFailTimeout(-1); return dataSource; } diff --git a/src/main/java/com/kri/kart/server/service/DerivedManagementService.java b/src/main/java/com/kri/kart/server/service/DerivedManagementService.java index f68fd92..a1bffd3 100644 --- a/src/main/java/com/kri/kart/server/service/DerivedManagementService.java +++ b/src/main/java/com/kri/kart/server/service/DerivedManagementService.java @@ -11,6 +11,7 @@ import com.kri.kart.server.dto.derived.DerivedSaveRequestDto; import com.kri.kart.server.dto.project.ProjectRefDto; import com.kri.kart.server.persistence.repository.DerivedRepository; import com.kri.kart.server.service.derived.DerivedComputationService; +import com.kri.kart.server.service.derived.DerivedRecalculationGuard; import java.util.List; import java.util.Objects; import java.util.function.Supplier; @@ -28,6 +29,7 @@ public class DerivedManagementService { private final DerivedComputationService derivedComputationService; private final LogService logService; private final ObjectMapper objectMapper; + private final DerivedRecalculationGuard derivedRecalculationGuard; private final PlatformTransactionManager konTransactionManager; private final PlatformTransactionManager konkiwiTransactionManager; @@ -37,6 +39,7 @@ public class DerivedManagementService { DerivedComputationService derivedComputationService, LogService logService, ObjectMapper objectMapper, + DerivedRecalculationGuard derivedRecalculationGuard, @Qualifier("konTransactionManager") PlatformTransactionManager konTransactionManager, @Qualifier("konkiwiTransactionManager") PlatformTransactionManager konkiwiTransactionManager) { @@ -45,6 +48,7 @@ public class DerivedManagementService { this.derivedComputationService = derivedComputationService; this.logService = logService; this.objectMapper = objectMapper; + this.derivedRecalculationGuard = derivedRecalculationGuard; this.konTransactionManager = konTransactionManager; this.konkiwiTransactionManager = konkiwiTransactionManager; } @@ -152,7 +156,7 @@ public class DerivedManagementService { if (idkey == null || idkey.isBlank() || idkey.length() > 512) { throw BusinessException.badRequest("응답자 ID를 확인해 주세요."); } - return transaction( + return derivedRecalculationGuard.execute(project, () -> transaction( project, () -> { requireProject(project); @@ -166,7 +170,7 @@ public class DerivedManagementService { matched += calculate(project, definition, idkey, derivedIds); } return new DerivedCalculationDto(definitions.size(), matched); - }); + })); } /** Stored derived variable IDs; uploaded response columns with these IDs are not imported. */ diff --git a/src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java b/src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java new file mode 100644 index 0000000..d34c6f8 --- /dev/null +++ b/src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java @@ -0,0 +1,86 @@ +package com.kri.kart.server.service.derived; + +import com.kri.common.feature.web.BusinessException; +import com.kri.kart.server.common.enums.ProjectType; +import com.kri.kart.server.config.KartDatabaseProperties; +import com.kri.kart.server.dto.project.ProjectRefDto; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Semaphore; +import java.util.concurrent.TimeUnit; +import java.util.function.Supplier; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.http.HttpStatus; +import org.springframework.stereotype.Component; + +/** Wait before borrowing JDBC connections; database locks still enforce cross-instance safety. */ +@Component +@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true") +public class DerivedRecalculationGuard { + private final ConcurrentHashMap projects = new ConcurrentHashMap<>(); + private final Semaphore kon; + private final Semaphore konkiwi; + private final long waitNanos; + + @Autowired + public DerivedRecalculationGuard(KartDatabaseProperties properties) { + this(properties, TimeUnit.SECONDS.toNanos(10)); + } + + DerivedRecalculationGuard(KartDatabaseProperties properties, long waitNanos) { + // Reserve one connection for access checks and other operations when pool size permits. + this.kon = new Semaphore(Math.max(1, properties.getKon().getMaximumPoolSize() - 1), true); + this.konkiwi = new Semaphore(Math.max(1, properties.getKonkiwi().getMaximumPoolSize() - 1), true); + this.waitNanos = waitNanos; + } + + public T execute(ProjectRefDto project, Supplier action) { + long deadline = System.nanoTime() + waitNanos; + ProjectGate gate = projects.compute(project, (key, current) -> { + ProjectGate selected = current == null ? new ProjectGate() : current; + selected.users++; + return selected; + }); + Semaphore source = project.projectType() == ProjectType.KON ? kon : konkiwi; + boolean projectAcquired = false; + boolean sourceAcquired = false; + try { + projectAcquired = gate.permit.tryAcquire(remaining(deadline), TimeUnit.NANOSECONDS); + if (!projectAcquired) { + throw busy(); + } + sourceAcquired = source.tryAcquire(remaining(deadline), TimeUnit.NANOSECONDS); + if (!sourceAcquired) { + throw busy(); + } + return action.get(); + } catch (InterruptedException error) { + Thread.currentThread().interrupt(); + throw busy(); + } finally { + if (sourceAcquired) { + source.release(); + } + if (projectAcquired) { + gate.permit.release(); + } + projects.computeIfPresent(project, (key, current) -> --current.users == 0 ? null : current); + } + } + + private long remaining(long deadline) { + return Math.max(0, deadline - System.nanoTime()); + } + + private BusinessException busy() { + return BusinessException.of( + HttpStatus.SERVICE_UNAVAILABLE, "DERIVED_RECALCULATION_BUSY", + "파생변수 재계산 요청이 많습니다. 잠시 후 다시 요청해 주세요."); + } + + private static final class ProjectGate { + private final Semaphore permit = new Semaphore(1, true); + // Accessed only inside ConcurrentHashMap.compute/computeIfPresent for the project. + private int users; + } +} diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml index 1c28c76..a9180ba 100644 --- a/src/main/resources/application.yml +++ b/src/main/resources/application.yml @@ -3,6 +3,9 @@ server: forward-headers-strategy: framework spring: + datasource: + hikari: + leak-detection-threshold: 30000 application: name: kart-server profiles: