release: 2.1.6 (#387)

Author: devxb

gradle.properties

@@ -49,3 +49,6 @@ slackVersion=1.40.2
 
 ### Jackson version ###
 jacksonVersion=2.15.3
+
+### Redisson ###
+redissonVersion=3.47.0

gradle/core.gradle

@@ -2,4 +2,5 @@ dependencies {
     implementation "org.rooftopmsa:netx:${netxVersion}"
     implementation "com.github.ben-manes.caffeine:caffeine:${caffeineCacheVersion}"
     implementation "com.fasterxml.jackson.module:jackson-module-kotlin:${jacksonVersion}"
+    implementation "org.redisson:redisson-spring-boot-starter:${redissonVersion}"
 }

src/main/kotlin/org/gitanimals/core/HttpClientErrorHandler.kt

@@ -0,0 +1,26 @@
+package org.gitanimals.core
+
+import org.springframework.http.HttpStatus
+import org.springframework.http.client.ClientHttpResponse
+import org.springframework.web.client.ResponseErrorHandler
+
+class HttpClientErrorHandler : ResponseErrorHandler {
+
+    override fun hasError(response: ClientHttpResponse): Boolean {
+        return response.statusCode.isError
+    }
+
+    override fun handleError(response: ClientHttpResponse) {
+        val body = response.body.bufferedReader().use { it.readText() }
+        when {
+            response.statusCode.isSameCodeAs(HttpStatus.UNAUTHORIZED) ->
+                throw AuthorizationException(body)
+
+            response.statusCode.is4xxClientError ->
+                throw IllegalArgumentException(body)
+
+            response.statusCode.is5xxServerError ->
+                throw IllegalStateException(body)
+        }
+    }
+}

src/main/kotlin/org/gitanimals/core/UpdateUserOrchestrator.kt

@@ -0,0 +1,16 @@
+package org.gitanimals.core
+
+import org.gitanimals.core.auth.UserEntryPoint
+
+fun interface UpdateUserOrchestrator {
+
+    fun updateUsername(request: UpdateUserNameRequest)
+
+    data class UpdateUserNameRequest(
+        val id: Long,
+        val authenticationId: String,
+        val entryPoint: UserEntryPoint,
+        val previousName: String,
+        val changeName: String,
+    )
+}

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

@@ -0,0 +1,46 @@
+package org.gitanimals.core.lock
+
+import org.springframework.stereotype.Component
+import kotlin.time.Duration.Companion.seconds
+
+object LOCK_KEY_PREFIX {
+    const val CREATE_NEW_USER = "CREATE_NEW_USER"
+    const val SET_AUTH = "SET_AUTH"
+}
+
+object DistributedLock {
+
+    private lateinit var lockService: DistributedLockService
+
+    fun <T> withLock(
+        key: String,
+        leaseMillis: Long = 10.seconds.inWholeMilliseconds,
+        waitMillis: Long = 3.seconds.inWholeMilliseconds,
+        action: () -> T,
+    ): T {
+        return lockService.withLock(
+            key = key,
+            leaseMillis = leaseMillis,
+            waitMillis = waitMillis,
+            action = action,
+        )
+    }
+
+    interface DistributedLockService {
+
+        fun <T> withLock(
+            key: String,
+            leaseMillis: Long = 10.seconds.inWholeMilliseconds,
+            waitMillis: Long = 3.seconds.inWholeMilliseconds,
+            action: () -> T,
+        ): T
+    }
+
+    @Component
+    class DistributedLockServiceInjector(distributedLockService: DistributedLockService) {
+
+        init {
+            lockService = distributedLockService
+        }
+    }
+}

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

@@ -0,0 +1,5 @@
+package org.gitanimals.core.lock
+
+class LockAcquireFailException(
+    override val message: String,
+) : RuntimeException(message)

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

@@ -0,0 +1,57 @@
+package org.gitanimals.core.lock
+
+import org.redisson.Redisson
+import org.redisson.api.RedissonClient
+import org.redisson.config.Config
+import org.springframework.beans.factory.annotation.Value
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.stereotype.Component
+import java.util.concurrent.TimeUnit
+
+@Component
+class RedisDistributedLockService(
+    private val redissonClient: RedissonClient,
+) : DistributedLock.DistributedLockService {
+
+    override fun <T> withLock(
+        key: String,
+        leaseMillis: Long,
+        waitMillis: Long,
+        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()
+            }
+        } else {
+            throw LockAcquireFailException(message = "Cannot acquire lock")
+        }
+    }
+}
+
+@Configuration
+class RedissonConfig(
+    @Value("\${netx.host}") private val host: String,
+    @Value("\${netx.port}") private val port: String,
+    @Value("\${netx.password:0000}") private val password: String,
+) {
+
+    @Bean
+    fun redissonClient(): RedissonClient {
+        val config = Config()
+
+        config.useSingleServer()
+            .setAddress("redis://$host:$port")
+//            .setPassword(password)
+
+        return Redisson.create(config)
+    }
+}

src/main/kotlin/org/gitanimals/guild/domain/Guild.kt

@@ -1,11 +1,7 @@
 package org.gitanimals.guild.domain
 
 import jakarta.persistence.*
-import org.gitanimals.core.AggregateRoot
-import org.gitanimals.core.FieldType
-import org.gitanimals.core.IdGenerator
-import org.gitanimals.core.PersonaType
-import org.gitanimals.core.DomainEventPublisher
+import org.gitanimals.core.*
 import org.gitanimals.guild.domain.event.GuildContributionUpdated
 import org.gitanimals.guild.domain.extension.GuildFieldTypeExtension.isGuildField
 import org.gitanimals.guild.domain.request.ChangeGuildRequest
@@ -16,7 +12,8 @@ import org.hibernate.annotations.BatchSize
 @Table(
     name = "guild",
     indexes = [
-        Index(name = "guild_idx_title", unique = true, columnList = "title")
+        Index(name = "guild_idx_title", unique = true, columnList = "title"),
+        Index(name = "guild_idx_leader_name", columnList = "name"),
     ]
 )
 class Guild(
@@ -161,8 +158,7 @@ class Guild(
         val beforeContributions = this.getTotalContributions()
         if (leader.name == username) {
             leader.contributions = contributions
-        }
-        else {
+        } else {
             members.firstOrNull { it.name == username }?.setContributions(contributions)
         }
         val afterContributions = this.getTotalContributions()
@@ -238,6 +234,15 @@ class Guild(
         members.removeIf { it.userId == userId }
     }
 
+    fun updateUserName(previousName: String, changeName: String) {
+        if (leader.name == previousName) {
+            leader.name = changeName
+        }
+
+        members.filter { it.name == previousName }.forEach { it.name = changeName }
+        waitMembers.filter { it.name == previousName }.forEach { it.name = changeName }
+    }
+
     companion object {
 
         private const val LEADER_SIZE = 1

src/main/kotlin/org/gitanimals/guild/domain/GuildRepository.kt

@@ -2,6 +2,7 @@ package org.gitanimals.guild.domain
 
 import org.springframework.data.domain.Page
 import org.springframework.data.domain.Pageable
+import org.springframework.data.domain.Slice
 import org.springframework.data.jpa.repository.JpaRepository
 import org.springframework.data.jpa.repository.Query
 import org.springframework.data.repository.query.Param
@@ -105,4 +106,14 @@ interface GuildRepository : JpaRepository<Guild, Long> {
         """
     )
     fun searchByContributionCountDesc(pageable: Pageable): Page<Guild>
+
+    @Query(
+        """
+            select g from Guild as g
+            left join fetch g.members as m
+            left join g.waitMembers as wm
+            where g.leader.name = :name or m.name = :name or wm.name = :name
+        """
+    )
+    fun findAllByNameContains(@Param("name") name: String, pageable: Pageable): Slice<Guild>
 }

src/main/kotlin/org/gitanimals/guild/domain/GuildService.kt

@@ -150,6 +150,16 @@ class GuildService(
         }
     }
 
+    @Transactional
+    @Retryable(ObjectOptimisticLockingFailureException::class)
+    fun updateUsername(previousName: String, changeName: String, pageable: Pageable) {
+        val users = guildRepository.findAllByNameContains(name = previousName, pageable = pageable)
+
+        users.content.forEach {
+            it.updateUserName(previousName, changeName)
+        }
+    }
+
     fun search(text: String, pageNumber: Int, filter: SearchFilter): Page<Guild> {
         return if (text.isBlank()) {
             when (filter) {