MOSU-249 feat: 배포 환경에 따른 yml 분리

.github/workflows/docker-depoly.yaml

@@ -22,9 +22,16 @@ jobs:
           script: |
             cd /home/ubuntu/mosu
 
-            echo "${{ secrets.ENV_BLUE }}" > .env.blue
-            echo "${{ secrets.ENV_GREEN }}" > .env.green
+            echo "${{ secrets.ENV_BASE }}" > .env
+            echo "${{ secrets.ENV_BASE }}" > .env.blue
+            echo "${{ secrets.ENV_BASE }}" > .env.green
 
+            echo "${{ secrets.ENV }}" >> .env
+            echo "${{ secrets.ENV }}" >> .env.blue
+            echo "${{ secrets.ENV }}" >> .env.green
+
+            echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env
             echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.blue
             echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.green
+
             ./deploy.sh

.github/workflows/self-depoly.yaml

@@ -3,20 +3,68 @@ name: Docker CI/CD - Deploy
 on:
   workflow_dispatch:
     branches:
-      - test
+      - develop
 jobs:
   deploy:
     runs-on: self-hosted
 
     steps:
+      - name: Checkout source
+        uses: actions/checkout@v3
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v3
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Cache Gradle files
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: gradle-${{ runner.os }}-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            gradle-${{ runner.os }}-
+
+      - name: Clone external repo with jar into libs/
+        run: |
+          mkdir -p libs
+          git clone https://x-access-token:${{ secrets.GH_PAT }}@github.com/mosu-dev/mosu-kmc-jar.git temp-jar
+          cp temp-jar/*.jar libs/
+
+      - name: Build with Gradle
+        run: ./gradlew build -x test
+
+      - name: Log in to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build Docker image
+        run: docker build -t kangtaehyun1107/mosu-server:${{ github.sha }} .
+        working-directory:
+      - name: Push Docker image
+        run: docker push kangtaehyun1107/mosu-server:${{ github.sha }}
+
       - name: Deploy via SSH
         run: |
           cd ~/mosu-server
 
-          echo "${{ secrets.TEST_ENV_BLUE }}" > .env.blue
-          echo "${{ secrets.TEST_ENV_GREEN }}" > .env.green
+          echo "${{ secrets.ENV_BASE }}" > .env
+          echo "${{ secrets.ENV_BASE }}" > .env.blue
+          echo "${{ secrets.ENV_BASE }}" > .env.green
+
+          echo "${{ secrets.ENV_TEST }}" >> .env
+          echo "${{ secrets.ENV_TEST }}" >> .env.blue
+          echo "${{ secrets.ENV_TEST }}" >> .env.green
+
+          echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env
           echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.blue
           echo "APP_IMAGE_VERSION=${{ github.sha }}" >> .env.green
+
           sudo docker stop $(sudo docker ps -aq) || true
           sudo docker rm $(sudo docker ps -aq) || true
           echo "Stopping all containers..."

build.gradle

@@ -29,16 +29,17 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-web'
     implementation 'org.springframework.boot:spring-boot-starter-validation'
-    testImplementation 'org.projectlombok:lombok'
-    testImplementation 'org.projectlombok:lombok'
-    testCompileOnly 'org.projectlombok:lombok'
-    testAnnotationProcessor 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
-    compileOnly 'org.projectlombok:lombok'
-    annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 
+    // Lombok
+    compileOnly 'org.projectlombok:lombok'
+    annotationProcessor 'org.projectlombok:lombok'
+    testCompileOnly 'org.projectlombok:lombok'
+    testImplementation 'org.projectlombok:lombok'
+    testAnnotationProcessor 'org.projectlombok:lombok'
+
     // 인증사 관련 의존성
     implementation 'javax.servlet:jstl:1.2'
     implementation "org.apache.tomcat.embed:tomcat-embed-jasper"
@@ -69,7 +70,6 @@ dependencies {
     testImplementation 'org.testcontainers:junit-jupiter:1.19.3'
     testImplementation 'org.testcontainers:mysql:1.20.0'
 
-
     // security
     implementation 'org.springframework.boot:spring-boot-starter-security'
     implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'
@@ -103,11 +103,6 @@ dependencies {
 
     runtimeOnly 'com.h2database:h2'
 
-    testImplementation 'org.springframework.boot:spring-boot-testcontainers:3.3.5'
-    testImplementation 'org.testcontainers:testcontainers:1.19.3'
-    testImplementation 'org.testcontainers:junit-jupiter:1.19.3'
-    testImplementation 'org.testcoscntainers:mysql:1.20.0'
-
     annotationProcessor "org.springframework.boot:spring-boot-configuration-processor"
 
     implementation 'org.apache.commons:commons-pool2:2.12.1'

src/main/java/life/mosu/mosuserver/application/caffeine/LocalCacheConfig.java

@@ -0,0 +1,42 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import life.mosu.mosuserver.domain.caffeine.CacheGroup;
+import life.mosu.mosuserver.domain.caffeine.CacheType;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.annotation.EnableCaching;
+import org.springframework.cache.caffeine.CaffeineCache;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+@EnableCaching
+@Configuration
+public class LocalCacheConfig {
+
+    @Bean
+    public LocalCacheManager localCacheManager() {
+        List<Cache> caches = Arrays.stream(CacheGroup.values())
+                .filter(g -> g.getCacheType() == CacheType.LOCAL
+                        || g.getCacheType() == CacheType.COMPOSITE)
+                .map(g -> new CaffeineCache(
+                        g.getCacheName(),
+                        Caffeine.newBuilder()
+                                .recordStats()
+                                .expireAfterWrite(g.getExpiredAfterWrite())
+                                .build()
+                )).collect(Collectors.toList());
+
+        return new LocalCacheManager(caches);
+    }
+
+    @Bean
+    @Primary
+    public CacheManager appCacheManager(LocalCacheManager localCacheManager) {
+        return localCacheManager;
+    }
+}

src/main/java/life/mosu/mosuserver/application/caffeine/LocalCacheManager.java

@@ -0,0 +1,59 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import jakarta.annotation.Nullable;
+import jakarta.annotation.PostConstruct;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+
+public class LocalCacheManager implements CacheManager, UpdatableCacheManager {
+
+    private final List<Cache> caches;
+    private Map<String, Cache> cacheMap = new ConcurrentHashMap<>();
+    private volatile Set<String> cacheNames = Collections.emptySet();
+
+    public LocalCacheManager(List<Cache> caches) {
+        this.caches = (caches != null) ? caches : Collections.emptyList();
+    }
+
+    @PostConstruct
+    public void init() {
+        Set<String> cacheNamesSet = new LinkedHashSet<>(caches.size());
+        Map<String, Cache> cacheMapTemp = new ConcurrentHashMap<>(16);
+
+        for (Cache cache : caches) {
+            String name = cache.getName();
+            cacheNamesSet.add(name);
+            cacheMapTemp.put(name, cache);
+        }
+        this.cacheMap = cacheMapTemp;
+        this.cacheNames = cacheNamesSet;
+    }
+
+    @Override
+    @Nullable
+    public Cache getCache(String name) {
+        return cacheMap.get(name);
+    }
+
+    @Override
+    public Collection<String> getCacheNames() {
+        return cacheNames;
+    }
+
+    @Override
+    public void putIfAbsent(Cache cache, String key, Object value) {
+        Cache localCache = getCache(cache.getName());
+        if (localCache != null) {
+            localCache.putIfAbsent(key, value);
+        }
+    }
+
+
+}

src/main/java/life/mosu/mosuserver/application/caffeine/UpdatableCacheManager.java

@@ -0,0 +1,8 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import org.springframework.cache.Cache;
+
+public interface UpdatableCacheManager {
+
+    void putIfAbsent(Cache cache, String key, Object value);
+}

src/main/java/life/mosu/mosuserver/application/exam/cache/AtomicExamQuotaDecrementOperator.java

@@ -1,6 +1,8 @@
 package life.mosu.mosuserver.application.exam.cache;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
 import life.mosu.mosuserver.infra.persistence.redis.operator.VoidCacheAtomicOperator;
@@ -15,12 +17,17 @@ public class AtomicExamQuotaDecrementOperator implements VoidCacheAtomicOperator
     private final RedisTemplate<String, Long> redisTemplate;
     private final DefaultRedisScript<Long> decrementScript;
 
+
     public AtomicExamQuotaDecrementOperator(
             RedisTemplate<String, Long> redisTemplate,
-            @Qualifier("decrementExamQuotaScript") DefaultRedisScript<Long> decrementScript
+
+            @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
+            @Qualifier("examLuaScripts")
+            Map<String, DefaultRedisScript<Long>> examLuaScripts
     ) {
         this.redisTemplate = redisTemplate;
-        this.decrementScript = decrementScript;
+        this.decrementScript = Objects.requireNonNull(examLuaScripts.get("decrementQuota"),
+                "Redis script 'decrementQuota' not found");
     }
 
     @Override

src/main/java/life/mosu/mosuserver/application/exam/cache/AtomicExamQuotaIncrementOperator.java

@@ -1,26 +1,34 @@
 package life.mosu.mosuserver.application.exam.cache;
 
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
 import life.mosu.mosuserver.infra.persistence.redis.operator.VoidCacheAtomicOperator;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.data.redis.core.script.DefaultRedisScript;
 import org.springframework.stereotype.Component;
 
 @Component
+@Slf4j
 public class AtomicExamQuotaIncrementOperator implements VoidCacheAtomicOperator<String, Long> {
 
     private final RedisTemplate<String, Long> redisTemplate;
-    private final DefaultRedisScript<Long> decrementScript;
+    private final DefaultRedisScript<Long> incrementScript;
 
     public AtomicExamQuotaIncrementOperator(
             RedisTemplate<String, Long> redisTemplate,
-            @Qualifier("incrementExamQuotaScript") DefaultRedisScript<Long> decrementScript
+
+            @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
+            @Qualifier("examLuaScripts")
+            Map<String, DefaultRedisScript<Long>> examLuaScripts
     ) {
         this.redisTemplate = redisTemplate;
-        this.decrementScript = decrementScript;
+        this.incrementScript = Objects.requireNonNull(examLuaScripts.get("incrementQuota"),
+                "Redis script 'incrementQuota' not found");
     }
 
     @Override
@@ -36,7 +44,7 @@ public String getActionName() {
     @Override
     public void execute(String key) {
         try {
-            Long result = redisTemplate.execute(decrementScript, List.of(
+            Long result = redisTemplate.execute(incrementScript, List.of(
                     ExamQuotaPrefix.CURRENT_APPLICATIONS.with(key),
                     ExamQuotaPrefix.MAX_CAPACITY.with(key)
             ));

src/main/java/life/mosu/mosuserver/application/exam/cache/ExamQuotaCacheManager.java

@@ -14,6 +14,7 @@
 import life.mosu.mosuserver.infra.persistence.redis.operator.VoidCacheAtomicOperator;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
@@ -29,7 +30,9 @@ public ExamQuotaCacheManager(
             CacheWriter<String, Long> cacheWriter,
             CacheReader<String, Long> cacheReader,
 
-            @Qualifier("examCacheAtomicOperatorMap")
+            @Lazy
+            @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
+            @Qualifier("examQuotaCacheAtomicOperatorMap")
             Map<String, ? extends CacheAtomicOperator<String, Long>> cacheAtomicOperatorMap,
             ExamJpaRepository examJpaRepository
     ) {

src/main/java/life/mosu/mosuserver/application/inquiry/InquiryService.java

@@ -3,16 +3,15 @@
 import life.mosu.mosuserver.domain.inquiry.entity.InquiryJpaEntity;
 import life.mosu.mosuserver.domain.inquiry.entity.InquiryStatus;
 import life.mosu.mosuserver.domain.inquiry.repository.InquiryJpaRepository;
-import life.mosu.mosuserver.domain.inquiryAnswer.repository.InquiryAnswerJpaRepository;
 import life.mosu.mosuserver.domain.user.entity.UserJpaEntity;
 import life.mosu.mosuserver.domain.user.entity.UserRole;
-import life.mosu.mosuserver.domain.user.repository.UserJpaRepository;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryCreateRequest;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryDetailResponse;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryDetailResponse.InquiryAnswerDetailResponse;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryResponse;
+import life.mosu.mosuserver.presentation.inquiry.dto.InquiryUpdateRequest;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.domain.Page;
@@ -26,11 +25,9 @@
 @RequiredArgsConstructor
 public class InquiryService {
 
-    private final UserJpaRepository userJpaRepository;
     private final InquiryAttachmentService inquiryAttachmentService;
     private final InquiryJpaRepository inquiryJpaRepository;
     private final InquiryAnswerService inquiryAnswerService;
-    private final InquiryAnswerJpaRepository inquiryAnswerJpaRepository;
 
     @Transactional
     public void createInquiry(UserJpaEntity user, InquiryCreateRequest request) {
@@ -74,6 +71,17 @@ public void deleteInquiry(UserJpaEntity user, Long postId) {
         inquiryJpaRepository.delete(inquiry);
     }
 
+    @Transactional
+    public void updateInquiry(UserJpaEntity user, InquiryUpdateRequest request, Long postId) {
+        InquiryJpaEntity inquiry = getInquiry(postId);
+        hasPermission(inquiry.getUserId(), user);
+
+        inquiry.update(request.title(), request.content(), user.getName());
+        inquiryJpaRepository.save(inquiry);
+
+        inquiryAttachmentService.updateAttachment(request.attachments(), inquiry);
+    }
+
     private InquiryDetailResponse toInquiryDetailResponse(InquiryJpaEntity inquiry) {
         InquiryAnswerDetailResponse answer = inquiryAnswerService.getInquiryAnswerDetail(
                 inquiry.getId());