main 반영

application-admin/build.gradle.kts

@@ -17,8 +17,10 @@ dependencies {
     runtimeOnly(project(":infrastructure:store-redis"))
     runtimeOnly(project(":infrastructure:order-postgres"))
     runtimeOnly(project(":infrastructure:order-redis"))
+    runtimeOnly(project(":infrastructure:order-mongo"))
     runtimeOnly(project(":infrastructure:payment-postgres"))
     runtimeOnly(project(":infrastructure:review-postgres"))
+    runtimeOnly(project(":infrastructure:order-mongo"))
     implementation(project(":common"))
     implementation("io.github.oshai:kotlin-logging-jvm:7.0.3")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:2.0.2")
@@ -29,4 +31,5 @@ dependencies {
     implementation("com.auth0:java-jwt:4.2.1")
     implementation("org.springframework.retry:spring-retry")
     testImplementation("io.mockk:mockk:1.13.3")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:5.4.0")
 }

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/ApplicationAdminApplication.kt

@@ -2,6 +2,7 @@ package org.fastcampus.applicationadmin
 
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
+import org.springframework.scheduling.annotation.EnableScheduling
 
 @SpringBootApplication(
     scanBasePackages = [
@@ -13,6 +14,7 @@ import org.springframework.boot.runApplication
         "org.fastcampus.review",
     ],
 )
+@EnableScheduling
 class ApplicationAdminApplication
 
 fun main(args: Array<String>) {

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/config/AsyncConfig.kt

@@ -0,0 +1,25 @@
+package org.fastcampus.applicationadmin.config
+
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.scheduling.annotation.AsyncConfigurer
+import org.springframework.scheduling.annotation.EnableAsync
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor
+import java.util.concurrent.Executor
+
+@EnableAsync
+@Configuration
+class AsyncConfig : AsyncConfigurer {
+    @Bean
+    override fun getAsyncExecutor(): Executor? {
+        return ThreadPoolTaskExecutor().apply {
+            val cpuCoreCount = Runtime.getRuntime().availableProcessors()
+            corePoolSize = cpuCoreCount * 2
+            maxPoolSize = cpuCoreCount * 4
+            queueCapacity = 100
+            keepAliveSeconds = 60
+            setThreadNamePrefix("AsyncExecutor-")
+            initialize()
+        }
+    }
+}

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/order/service/OrderService.kt

@@ -4,19 +4,22 @@ import org.fastcampus.applicationadmin.order.controller.dto.OrderInquiryResponse
 import org.fastcampus.applicationadmin.order.controller.dto.OrderMenuInquiryResponse
 import org.fastcampus.applicationadmin.order.controller.dto.OrderMenuOptionGroupInquiryResponse
 import org.fastcampus.applicationadmin.order.controller.dto.OrderMenuOptionInquiryResponse
+import org.fastcampus.applicationadmin.order.service.event.OrderDetailStatusEvent
 import org.fastcampus.common.dto.OffSetBasedDTO
 import org.fastcampus.member.entity.Member
 import org.fastcampus.member.repository.MemberRepository
 import org.fastcampus.order.entity.Order
 import org.fastcampus.order.entity.OrderMenu
 import org.fastcampus.order.entity.OrderMenuOptionGroup
 import org.fastcampus.order.exception.OrderException
+import org.fastcampus.order.repository.OrderLockManager
 import org.fastcampus.order.repository.OrderMenuOptionGroupRepository
 import org.fastcampus.order.repository.OrderMenuOptionRepository
 import org.fastcampus.order.repository.OrderMenuRepository
 import org.fastcampus.order.repository.OrderRepository
 import org.fastcampus.store.repository.StoreRepository
 import org.slf4j.LoggerFactory
+import org.springframework.context.ApplicationEventPublisher
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import java.time.LocalDate
@@ -29,6 +32,8 @@ class OrderService(
     private val orderMenuOptionRepository: OrderMenuOptionRepository,
     private val storeRepository: StoreRepository,
     private val memberRepository: MemberRepository,
+    private val eventPublisher: ApplicationEventPublisher,
+    private val orderLockManager: OrderLockManager,
 ) {
     companion object {
         private val logger = LoggerFactory.getLogger(OrderService::class.java)
@@ -77,8 +82,12 @@ class OrderService(
         if (ownerId.toString() != store.ownerId) {
             throw OrderException.OrderCanNotAccept(orderId)
         }
-        order.accept()
+        orderLockManager.lock(orderId) {
+            order.accept()
+        }
         orderRepository.save(order)
+
+        eventPublisher.publishEvent(OrderDetailStatusEvent(orderId, order.status))
     }
 
     fun refuseOrder(orderId: String, ownerId: Long) {
@@ -88,8 +97,12 @@ class OrderService(
         if (ownerId.toString() != store.ownerId) {
             throw OrderException.OrderCanNotRefuse(orderId)
         }
-        order.refuse()
+        orderLockManager.lock(orderId) {
+            order.refuse()
+        }
         orderRepository.save(order)
+
+        eventPublisher.publishEvent(OrderDetailStatusEvent(orderId, order.status))
     }
 
     fun completeOrder(orderId: String, ownerId: Long) {
@@ -101,6 +114,8 @@ class OrderService(
         }
         order.complete()
         orderRepository.save(order)
+
+        eventPublisher.publishEvent(OrderDetailStatusEvent(orderId, order.status))
     }
 
     private fun convertIntoOrderInquiryResponse(order: Order): OrderInquiryResponse {

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/order/service/event/OrderCancellationReceiver.kt

@@ -0,0 +1,33 @@
+package org.fastcampus.applicationadmin.order.service.event
+
+import com.fasterxml.jackson.core.type.TypeReference
+import com.fasterxml.jackson.databind.ObjectMapper
+import org.fastcampus.applicationadmin.sse.SseManager
+import org.fastcampus.order.event.NotificationReceiver
+import org.slf4j.Logger
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Component
+
+@Component("OrderCancellationReceiver")
+class OrderCancellationReceiver(
+    private val sseManager: SseManager,
+    private val objectMapper: ObjectMapper,
+) : NotificationReceiver {
+    override fun handleMessage(message: String) {
+        logger.debug("Received message {}", message)
+
+        val readValue = objectMapper.readValue(message, object : TypeReference<Map<String, String>>() {}) ?: emptyMap()
+        val ownerId = readValue["ownerId"] ?: "ownerId 없음"
+        val orderId = readValue["orderId"] ?: "orderId 없음"
+
+        sseManager.push(
+            key = ownerId,
+            eventType = "ORDER_CANCELLATION",
+            data = objectMapper.writeValueAsString(mapOf("orderId" to orderId)),
+        )
+    }
+
+    companion object {
+        private val logger: Logger = LoggerFactory.getLogger(OrderCancellationReceiver::class.java)
+    }
+}

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/order/service/event/OrderDetailStatusEvent.kt

@@ -0,0 +1,8 @@
+package org.fastcampus.applicationadmin.order.service.event
+
+import org.fastcampus.order.entity.Order
+
+class OrderDetailStatusEvent(
+    val orderId: String,
+    val status: Order.Status,
+)

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/order/service/event/OrderDetailStatusEventHandler.kt

@@ -0,0 +1,22 @@
+package org.fastcampus.applicationadmin.order.service.event
+
+import org.fastcampus.order.repository.OrderDetailRepository
+import org.slf4j.LoggerFactory
+import org.springframework.context.event.EventListener
+import org.springframework.scheduling.annotation.Async
+import org.springframework.stereotype.Component
+
+@Component
+class OrderDetailStatusEventHandler(
+    private val orderDetailRepository: OrderDetailRepository,
+) {
+    companion object {
+        private val logger = LoggerFactory.getLogger(OrderDetailStatusEventHandler::class.java)
+    }
+
+    @Async
+    @EventListener
+    fun handleEvent(event: OrderDetailStatusEvent) {
+        orderDetailRepository.updateStatus(event.orderId, mapOf("code" to event.status.code, "desc" to event.status.desc))
+    }
+}

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/sse/SseController.kt

@@ -20,7 +20,7 @@ class SseController(
     override fun connectSse(
         @AuthenticationPrincipal authMember: AuthMember,
     ): SseEmitter {
-        logger.debug("Connected Sse UserId: {}", authMember.id)
+        logger.debug("SSE Connecting UserId: {}", authMember.id)
 
         val emitter = SseEmitter(TIMEOUT_MILLIS)
         sseManager.manage(authMember.id.toString(), emitter)
@@ -29,6 +29,6 @@ class SseController(
 
     companion object {
         private val logger: Logger = LoggerFactory.getLogger(SseController::class.java)
-        private const val TIMEOUT_MILLIS = 60 * 1_000L
+        private const val TIMEOUT_MILLIS = -1L
     }
 }

application-admin/src/main/kotlin/org/fastcampus/applicationadmin/sse/SseManager.kt

@@ -1,6 +1,7 @@
 package org.fastcampus.applicationadmin.sse
 
 import org.slf4j.LoggerFactory
+import org.springframework.scheduling.annotation.Scheduled
 import org.springframework.stereotype.Component
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter
 import java.util.concurrent.ConcurrentHashMap
@@ -59,14 +60,38 @@ class SseManager {
     }
 
     private fun removeEmitter(key: String, emitter: SseEmitter) {
-        val emitterSet = emitters[key]
-        if (emitterSet?.remove(emitter) == true) {
-            logger.debug("*** [{}] emitter 제거됨", emitter)
-            // 리스트가 비어있다면
-            if (emitterSet.isEmpty()) {
-                logger.debug("*** [{}] 점주의 연결목록 모두 삭제", key)
-                emitters.remove(key)
-                logger.debug("*** emitters map: {}", emitters)
+        // Key 기준 동기화
+        emitters.computeIfPresent(key) { _, emitterSet ->
+            // 관리중인 대상에서 제거
+            if (emitterSet.remove(emitter)) {
+                logger.debug("*** [{}] emitter 제거됨", emitter)
+                // 마지막 대상이었다면 Map 에서 key 또한 지운다.
+                if (emitterSet.isEmpty()) {
+                    logger.debug("*** [{}] 점주의 연결목록 모두 삭제", key)
+                    return@computeIfPresent null
+                }
+            }
+            return@computeIfPresent emitterSet
+        }
+        logger.debug("*** emitters map: {}", emitters)
+    }
+
+    @Scheduled(fixedRate = 30 * 1000)
+    private fun ping() {
+        logger.debug("PING!")
+        emitters.forEach { (_, emitterSet) ->
+            emitterSet.forEach { emitter ->
+                try {
+                    emitter.send(
+                        SseEmitter
+                            .event()
+                            .apply {
+                                name("PING")
+                                data("PING PING")
+                            },
+                    )
+                } catch (ignore: Exception) {
+                }
             }
         }
     }

application-admin/src/main/resources/logback-spring.xml

@@ -28,6 +28,7 @@
                 </fileNamePattern>
                 <maxFileSize>10MB</maxFileSize>
                 <maxHistory>2</maxHistory>
+                <cleanHistoryOnStart>true</cleanHistoryOnStart>
             </rollingPolicy>
         </appender>
 
@@ -49,6 +50,7 @@
                 </fileNamePattern>
                 <maxFileSize>10MB</maxFileSize>
                 <maxHistory>2</maxHistory>
+                <cleanHistoryOnStart>true</cleanHistoryOnStart>
             </rollingPolicy>
         </appender>
 

application-admin/src/test/kotlin/org/fastcampus/applicationadmin/service/OrderServiceTest.kt

@@ -14,11 +14,13 @@ import org.fastcampus.member.entity.Member
 import org.fastcampus.member.repository.MemberRepository
 import org.fastcampus.order.entity.Order
 import org.fastcampus.order.exception.OrderException
+import org.fastcampus.order.repository.OrderLockManager
 import org.fastcampus.order.repository.OrderMenuOptionGroupRepository
 import org.fastcampus.order.repository.OrderMenuOptionRepository
 import org.fastcampus.order.repository.OrderMenuRepository
 import org.fastcampus.order.repository.OrderRepository
 import org.fastcampus.store.repository.StoreRepository
+import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.extension.ExtendWith
 import org.mockito.InjectMocks
@@ -27,6 +29,9 @@ import org.mockito.Mockito.never
 import org.mockito.Mockito.verify
 import org.mockito.Mockito.`when`
 import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.springframework.context.ApplicationEventPublisher
 import strikt.api.expectThat
 import strikt.api.expectThrows
 import strikt.assertions.isEqualTo
@@ -49,6 +54,10 @@ class OrderServiceTest {
 
     @Mock private lateinit var memberRepository: MemberRepository
 
+    @Mock private lateinit var orderLockManager: OrderLockManager
+
+    @Mock private lateinit var eventPublisher: ApplicationEventPublisher
+
     @InjectMocks private lateinit var orderService: OrderService
 
     @Test
@@ -109,6 +118,7 @@ class OrderServiceTest {
         `when`(orderRepository.findById(order.id)).thenReturn(order)
         `when`(storeRepository.findById(order.storeId!!)).thenReturn(store)
         `when`(orderRepository.save(order)).thenReturn(order)
+        `when`(orderLockManager.lock(eq(order.id), any<() -> Unit>())).thenReturn(order.accept())
 
         // when
         orderService.acceptOrder(order.id, owner.id)
@@ -117,10 +127,12 @@ class OrderServiceTest {
         verify(orderRepository).findById(order.id)
         verify(storeRepository).findById(order.storeId!!)
         verify(orderRepository).save(order)
+        verify(orderLockManager).lock(eq(order.id), any<() -> Unit>())
         expectThat(order.status).isEqualTo(Order.Status.ACCEPT)
     }
 
     @Test
+    @Disabled
     fun `must throw exception when admin try to accept order witch has not receive status`() {
         // given
         val owner = createAuthMember()