release: 2.3.6 (#420)

Author: devxb

src/main/kotlin/org/gitanimals/core/lock/DistributedLock.kt

@@ -16,13 +16,15 @@ object DistributedLock {
         key: String,
         leaseMillis: Long = 10.seconds.inWholeMilliseconds,
         waitMillis: Long = 3.seconds.inWholeMilliseconds,
+        whenAcquireFailed : () -> T = throw LockAcquireFailException(message = "Cannot acquire lock"),
         action: () -> T,
     ): T {
         return lockService.withLock(
             key = key,
             leaseMillis = leaseMillis,
             waitMillis = waitMillis,
             action = action,
+            whenAcquireFail = whenAcquireFailed,
         )
     }
 
@@ -32,6 +34,7 @@ object DistributedLock {
             key: String,
             leaseMillis: Long = 10.seconds.inWholeMilliseconds,
             waitMillis: Long = 3.seconds.inWholeMilliseconds,
+            whenAcquireFail : () -> T = throw LockAcquireFailException(message = "Cannot acquire lock"),
             action: () -> T,
         ): T
     }

src/main/kotlin/org/gitanimals/core/lock/RedisDistributedLockService.kt

@@ -18,21 +18,22 @@ class RedisDistributedLockService(
         key: String,
         leaseMillis: Long,
         waitMillis: Long,
-        action: () -> T
+        whenAcquireFail : () -> T,
+        action: () -> T,
     ): T {
         val lock = redissonClient.getLock(key)
         val acquired = lock.tryLock(waitMillis, leaseMillis, TimeUnit.MILLISECONDS)
 
         return if (acquired) {
             runCatching {
                 action.invoke()
-            }.getOrElse {
-                throw it
             }.also {
                 lock.unlock()
+            }.getOrElse {
+                throw it
             }
         } else {
-            throw LockAcquireFailException(message = "Cannot acquire lock")
+            whenAcquireFail()
         }
     }
 }

src/main/kotlin/org/gitanimals/render/app/AnimationFacade.kt

@@ -5,8 +5,8 @@ import org.gitanimals.core.UpdateUserOrchestrator
 import org.gitanimals.core.auth.UserEntryPoint
 import org.gitanimals.core.filter.MDCFilter.Companion.TRACE_ID
 import org.gitanimals.core.lock.DistributedLock
+import org.gitanimals.core.lock.LOCK_KEY_PREFIX
 import org.gitanimals.core.lock.LOCK_KEY_PREFIX.CREATE_NEW_USER
-import org.gitanimals.core.lock.LOCK_KEY_PREFIX.SET_AUTH
 import org.gitanimals.render.domain.EntryPoint
 import org.gitanimals.render.domain.User
 import org.gitanimals.render.domain.UserService
@@ -34,7 +34,9 @@ class AnimationFacade(
     fun getFarmAnimation(username: String): String {
         return when (userService.existsByName(username)) {
             true -> {
-                setUserAuthInfoIfNotSet(username)
+                DistributedLock.withLock(key = "${LOCK_KEY_PREFIX.SET_AUTH}:$username") {
+                    setUserAuthInfoIfNotSet(username)
+                }
 
                 val svgAnimation = userService.getFarmAnimationByUsername(username)
                 eventPublisher.publishEvent(Visited(username, MDC.get(TRACE_ID)))
@@ -51,7 +53,9 @@ class AnimationFacade(
     fun getLineAnimation(username: String, personaId: Long, mode: Mode): String {
         return when (userService.existsByName(username)) {
             true -> {
-                setUserAuthInfoIfNotSet(username)
+                DistributedLock.withLock(key = "${LOCK_KEY_PREFIX.SET_AUTH}:$username") {
+                    setUserAuthInfoIfNotSet(username)
+                }
 
                 val svgAnimation = userService.getLineAnimationByUsername(username, personaId, mode)
                 eventPublisher.publishEvent(Visited(username, MDC.get(TRACE_ID)))
@@ -89,7 +93,10 @@ class AnimationFacade(
     }
 
     private fun createNewUser(username: String): User {
-        return DistributedLock.withLock(key = "$CREATE_NEW_USER:$username") {
+        return DistributedLock.withLock(
+            key = "$CREATE_NEW_USER:$username",
+            whenAcquireFailed = { userService.getUserByName(username) }
+        ) {
             runCatching {
                 val contributionYears = contributionApi.getAllContributionYears(username)
                 val contributionCountPerYear =
@@ -110,21 +117,19 @@ class AnimationFacade(
     }
 
     private fun setUserAuthInfoIfNotSet(username: String) {
-        DistributedLock.withLock(key = "$SET_AUTH:$username") {
-            runCatching {
-                val user = userService.getUserByName(username)
-
-                if (user.isAuthInfoSet().not()) {
-                    val githubUserAuthInfo = githubRestApi.getGithubUser(user.getName())
-                    userService.setAuthInfo(
-                        name = user.getName(),
-                        entryPoint = EntryPoint.GITHUB,
-                        authenticationId = githubUserAuthInfo.id,
-                    )
-                }
-            }.onFailure {
-                logger.info("Fail to update userAuthInfo cause: ${it.message}", it)
+        runCatching {
+            val user = userService.getUserByName(username)
+
+            if (user.isAuthInfoSet().not()) {
+                val githubUserAuthInfo = githubRestApi.getGithubUser(user.getName())
+                userService.setAuthInfo(
+                    name = user.getName(),
+                    entryPoint = EntryPoint.GITHUB,
+                    authenticationId = githubUserAuthInfo.id,
+                )
             }
+        }.onFailure {
+            logger.info("Fail to update userAuthInfo cause: ${it.message}", it)
         }
     }
 }

src/test/kotlin/org/gitanimals/core/lock/DistributedLockTest.kt

@@ -0,0 +1,39 @@
+package org.gitanimals.core.lock
+
+import com.ninjasquad.springmockk.MockkBean
+import io.kotest.core.annotation.DisplayName
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+import io.mockk.every
+import io.mockk.mockk
+import org.redisson.api.RLock
+import org.redisson.api.RedissonClient
+import org.springframework.test.context.ContextConfiguration
+
+@ContextConfiguration(
+    classes = [
+        RedisDistributedLockService::class
+    ]
+)
+@DisplayName("DistributedLock 클래스의")
+class DistributedLockTest(
+    private val redisDistributedLockService: RedisDistributedLockService,
+    @MockkBean(relaxed = true) private val redissonClient: RedissonClient,
+) : StringSpec({
+
+    "Redis 구현채는 Lock획득에 실패했을때, whenAcquireFail 구문을 실행한다"() {
+        // given
+        val rLock = mockk<RLock>()
+        every { redissonClient.getLock(any<String>()) } returns rLock
+        every { rLock.tryLock(any(), any(), any()) } returns false
+
+        // when
+        val result = redisDistributedLockService.withLock(
+            key = "test",
+            whenAcquireFail = { "whenAcquireFail" },
+        ) { "success" }
+
+        // then
+        result shouldBe "whenAcquireFail"
+    }
+})

src/test/kotlin/org/gitanimals/play/PlayGround.kt

@@ -0,0 +1,22 @@
+package org.gitanimals.play
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+
+class PlayGround : StringSpec({
+    "runCatching의 also구문은 runCatching에서 예외가 던져져도 동작한다"() {
+        var isRunAlso = false
+        shouldThrow<IllegalArgumentException> {
+            runCatching {
+                throw IllegalArgumentException("hello?")
+            }.also {
+                isRunAlso = true
+            }.getOrElse {
+                throw it
+            }
+        }
+
+        isRunAlso shouldBe true
+    }
+})