prod : 인증 인가 부분 수정 및 배포 (Redis 구성 공통화)

.github/workflows/self-depoly.yaml

@@ -3,12 +3,52 @@ 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

src/main/java/life/mosu/mosuserver/application/application/cron/ApplicationFailureLogCleanup.java → src/main/java/life/mosu/mosuserver/application/application/cron/ApplicationFailureLogCleanupExecutor.java

@@ -2,15 +2,15 @@
 
 import java.time.LocalDateTime;
 import life.mosu.mosuserver.domain.application.repository.ApplicationFailureLogJpaRepository;
-import life.mosu.mosuserver.global.support.LogCleanup;
+import life.mosu.mosuserver.global.support.cron.LogCleanupExecutor;
 import lombok.RequiredArgsConstructor;
 import org.quartz.DisallowConcurrentExecution;
 import org.springframework.stereotype.Component;
 
 @DisallowConcurrentExecution
 @Component
 @RequiredArgsConstructor
-public class ApplicationFailureLogCleanup implements LogCleanup {
+public class ApplicationFailureLogCleanupExecutor implements LogCleanupExecutor {
 
     private final ApplicationFailureLogJpaRepository applicationFailureLogJpaRepository;
 

src/main/java/life/mosu/mosuserver/application/application/cron/ApplicationFailureLogDomainArchiver.java → src/main/java/life/mosu/mosuserver/application/application/cron/ApplicationFailureLogDomainArchiveExecutor.java

@@ -11,18 +11,16 @@
 import life.mosu.mosuserver.domain.application.entity.ApplicationJpaEntity;
 import life.mosu.mosuserver.domain.application.repository.ApplicationFailureLogJpaRepository;
 import life.mosu.mosuserver.domain.application.repository.ApplicationJpaRepository;
-import life.mosu.mosuserver.global.support.DomainArchiver;
+import life.mosu.mosuserver.global.support.cron.DomainArchiveExecutor;
+import life.mosu.mosuserver.infra.cron.annotation.CronTarget;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.quartz.DisallowConcurrentExecution;
-import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 
 @Slf4j
-@DisallowConcurrentExecution
-@Component
+@CronTarget
 @RequiredArgsConstructor
-public class ApplicationFailureLogDomainArchiver implements DomainArchiver {
+public class ApplicationFailureLogDomainArchiveExecutor implements DomainArchiveExecutor {
 
     private final static Duration DURATION_HOURS_STANDARD = Duration.ofHours(1);
     private final static int BATCH_SIZE = 500;

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

@@ -0,0 +1,68 @@
+package life.mosu.mosuserver.application.caffeine;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import life.mosu.mosuserver.domain.caffeine.dto.BlockedIpHistory;
+import life.mosu.mosuserver.domain.caffeine.entity.BlockedIpHistoryLogJpaEntity;
+import life.mosu.mosuserver.domain.caffeine.repository.BlockedIpHistoryLogJpaJpaRepository;
+import life.mosu.mosuserver.global.filter.TimePenalty;
+import life.mosu.mosuserver.global.support.cron.DomainArchiveExecutor;
+import life.mosu.mosuserver.infra.cron.annotation.CronTarget;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+@CronTarget
+@RequiredArgsConstructor
+public class BlockedIpBatchAchiever implements DomainArchiveExecutor {
+
+    private final static Duration DURATION_HOURS_STANDARD = Duration.ofHours(1);
+    private final static int BATCH_SIZE = 500;
+
+    private final BlockedIpHistoryLogJpaJpaRepository blockedIpHistoryLogJpaRepository;
+    private final Cache<String, BlockedIpHistory> blockedHistoryCache;
+
+
+    @Override
+    public void archive() {
+        Map<String, BlockedIpHistory> blockedHistoryMap = blockedHistoryCache.asMap();
+
+        List<BlockedIpHistoryLogJpaEntity> logs = blockedHistoryMap.values().stream()
+                .filter(entry -> entry.getPenaltyLevel() == TimePenalty.LEVEL_5)
+                .map(this::createBlockedHistoryLog)
+                .toList();
+
+        if (logs.isEmpty()) {
+            log.debug("[BlockedIpArchiver] 저장할 로그가 없음.");
+            return;
+        }
+
+        for (int i = 0; i < logs.size(); i += BATCH_SIZE) {
+            int end = Math.min(i + BATCH_SIZE, logs.size());
+            List<BlockedIpHistoryLogJpaEntity> batch = logs.subList(i, end);
+
+            try {
+                blockedIpHistoryLogJpaRepository.saveAllUsingBatch(batch);
+                log.debug("[BlockedIpArchiver] 저장 완료: {}개", batch.size());
+            } catch (Exception e) {
+                log.error("[BlockedIpArchiver] 저장 실패: {}~{} 인덱스", i, end, e);
+            }
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "blocked-ip";
+    }
+
+    private BlockedIpHistoryLogJpaEntity createBlockedHistoryLog(
+            BlockedIpHistory blockedIpHistory) {
+        return new BlockedIpHistoryLogJpaEntity(
+                blockedIpHistory.getIp(),
+                blockedIpHistory.getPenaltyLevel(),
+                blockedIpHistory.getBlockedAt()
+        );
+    }
+}

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/InquiryAnswerAttachmentService.java

@@ -53,6 +53,15 @@ public List<InquiryDetailResponse.AttachmentDetailResponse> toAttachmentResponse
                 .toList();
     }
 
+    @Override
+    public void updateAttachment(
+            List<FileRequest> requests,
+            InquiryAnswerJpaEntity answerEntity
+    ) {
+        deleteAttachment(answerEntity);
+        createAttachment(requests, answerEntity);
+    }
+
     private InquiryDetailResponse.AttachmentResponse createAttachResponse(
             InquiryAnswerAttachmentEntity attachment) {
         String preSignedUrl = s3Service.getPreSignedUrl(attachment.getS3Key());
@@ -74,4 +83,5 @@ private InquiryDetailResponse.AttachmentDetailResponse createAttachDetailRespons
         );
     }
 
+
 }

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

@@ -4,6 +4,7 @@
 import life.mosu.mosuserver.domain.inquiry.repository.InquiryJpaRepository;
 import life.mosu.mosuserver.domain.inquiryAnswer.entity.InquiryAnswerJpaEntity;
 import life.mosu.mosuserver.domain.inquiryAnswer.repository.InquiryAnswerJpaRepository;
+import life.mosu.mosuserver.domain.user.entity.UserJpaEntity;
 import life.mosu.mosuserver.global.exception.CustomRuntimeException;
 import life.mosu.mosuserver.global.exception.ErrorCode;
 import life.mosu.mosuserver.presentation.inquiry.dto.InquiryAnswerRequest;
@@ -28,14 +29,14 @@ public class InquiryAnswerService {
     private final InquiryAnswerTxService eventTxService;
 
     @Transactional
-    public void createInquiryAnswer(Long postId, InquiryAnswerRequest request) {
+    public void createInquiryAnswer(Long postId, InquiryAnswerRequest request, UserJpaEntity user) {
         isAnswerAlreadyRegister(postId);
         InquiryJpaEntity inquiryEntity = getInquiry(postId);
         Long userId = inquiryEntity.getUserId();
 
         try {
             InquiryAnswerJpaEntity answerEntity = inquiryAnswerJpaRepository.save(
-                    request.toEntity(postId));
+                    request.toEntity(postId, user));
 
             answerAttachmentService.createAttachment(request.attachments(), answerEntity);
             inquiryEntity.updateStatusToComplete();
@@ -51,12 +52,12 @@ public void createInquiryAnswer(Long postId, InquiryAnswerRequest request) {
     @Transactional
     public void deleteInquiryAnswer(Long postId) {
         InquiryJpaEntity inquiryEntity = getInquiry(postId);
-
         InquiryAnswerJpaEntity answerEntity = inquiryAnswerJpaRepository.findByInquiryId(postId)
                 .orElseThrow(() -> new CustomRuntimeException(ErrorCode.INQUIRY_ANSWER_NOT_FOUND));
 
         inquiryAnswerJpaRepository.delete(answerEntity);
         inquiryEntity.updateStatusToPending();
+        answerAttachmentService.deleteAttachment(answerEntity);
     }
 
     @Transactional(readOnly = true, propagation = Propagation.SUPPORTS)
@@ -71,17 +72,14 @@ public InquiryDetailResponse.InquiryAnswerDetailResponse getInquiryAnswerDetail(
     }
 
     @Transactional
-    public void updateInquiryAnswer(Long postId, InquiryAnswerUpdateRequest request) {
-        InquiryJpaEntity inquiryEntity = getInquiry(postId);
-
+    public void updateInquiryAnswer(Long postId, InquiryAnswerUpdateRequest request, UserJpaEntity user) {
         InquiryAnswerJpaEntity answerEntity = inquiryAnswerJpaRepository.findByInquiryId(postId)
                 .orElseThrow(() -> new CustomRuntimeException(ErrorCode.INQUIRY_ANSWER_NOT_FOUND));
 
-        answerEntity.update(request.title(), request.content());
+        answerEntity.update(request.title(), request.content(), user.getName());
         inquiryAnswerJpaRepository.save(answerEntity);
 
-        answerAttachmentService.deleteAttachment(answerEntity);
-        answerAttachmentService.createAttachment(request.attachments(), answerEntity);
+        answerAttachmentService.updateAttachment(request.attachments(), answerEntity);
     }
 
     private InquiryJpaEntity getInquiry(Long postId) {
@@ -96,4 +94,6 @@ private void isAnswerAlreadyRegister(Long postId) {
     }
 
 
+
+
 }

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

@@ -38,6 +38,15 @@ public void deleteAttachment(InquiryJpaEntity entity) {
         inquiryAttachmentJpaRepository.deleteAll(attachments);
     }
 
+    @Override
+    public void updateAttachment(
+            List<FileRequest> requests,
+            InquiryJpaEntity inquiryEntity
+    ) {
+        deleteAttachment(inquiryEntity);
+        createAttachment(requests, inquiryEntity);
+    }
+
 
     public List<InquiryDetailResponse.AttachmentDetailResponse> toAttachmentResponses(
             InquiryJpaEntity inquiry) {

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

@@ -68,11 +68,9 @@ public void deleteInquiry(UserJpaEntity user, Long postId) {
         InquiryJpaEntity inquiry = getInquiry(postId);
         hasPermission(inquiry.getUserId(), user);
 
-        inquiryAnswerJpaRepository.findByInquiryId(postId).ifPresent(answer -> {
-            inquiryAnswerService.deleteInquiryAnswer(postId);
-        });
+        inquiryAnswerService.deleteInquiryAnswer(postId);
 
-//        inquiryAttachmentService.deleteAttachment(inquiry);
+        inquiryAttachmentService.deleteAttachment(inquiry);
         inquiryJpaRepository.delete(inquiry);
     }