outbox 패턴 적용

.github/workflows/require-codeowners-approval.yml

@@ -30,7 +30,7 @@ jobs:
               }
             });
 
-            const codeOwners = ['mingmingmon', 'mungsil'];
+            const codeOwners = ['mungsil'];
             const isAuthorCodeOwner = codeOwners.includes(prAuthor);
 
             let requiredApprovals = [];

README.md

@@ -20,6 +20,12 @@
 
 No Car 서버는 **자가용 없이**도 **편리하고 즐거운 여행**을 할 수 있도록 지원하여, 더 많은 사람들이 환경을 생각하며 여행을 즐길 수 있도록 하는 것을 목표로 합니다.
 
+---
+## 🛠️ 시스템 아키텍처
+![모하고노카_다이어그램 drawio](https://github.com/user-attachments/assets/34d2823f-b50d-494f-8e00-6c83302895b6)
+
+
+
 ---
 
 ## 👨🏻‍💻 Developer

build.gradle

@@ -2,6 +2,7 @@ plugins {
 	id 'java'
 	id 'org.springframework.boot' version '3.3.4'
 	id 'io.spring.dependency-management' version '1.1.6'
+	id "io.sentry.jvm.gradle" version "5.12.2"
 }
 
 group = 'com.example'
@@ -14,6 +15,10 @@ java {
 }
 
 configurations {
+	all {
+		exclude group: "commons-logging", module: "commons-logging"
+		exclude group: "org.slf4j", module: "slf4j-simple"
+	}
 	compileOnly {
 		extendsFrom annotationProcessor
 	}
@@ -27,32 +32,56 @@ dependencies {
 	// Web
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	implementation 'org.springframework.boot:spring-boot-starter-web-services'
+	implementation 'org.springframework.boot:spring-boot-starter-webflux'
 	compileOnly 'org.projectlombok:lombok'
 	annotationProcessor 'org.projectlombok:lombok'
 
 	// HTTP Client
 	implementation group: 'org.apache.httpcomponents.client5', name: 'httpclient5', version: '5.3.1'
 
+	// logging
+	implementation 'io.sentry:sentry-logback:8.22.0'
+
 	// Swagger
 	implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0'
 
 	// DB
-	implementation 'org.springframework.boot:spring-boot-starter-data-jdbc'
 	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
+	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 	runtimeOnly 'org.postgresql:postgresql'
+	implementation 'io.hypersistence:hypersistence-utils-hibernate-63:3.12.0'
 
 	// Actuator
 	implementation 'org.springframework.boot:spring-boot-starter-actuator'
 
 	// valid
 	implementation 'org.springframework.boot:spring-boot-starter-validation'
 
+	// retry
+	implementation 'org.springframework.retry:spring-retry'
+	implementation 'org.springframework:spring-aspects'
+
+	implementation 'net.logstash.logback:logstash-logback-encoder:9.0'
+
+	// notification
+	implementation 'com.google.firebase:firebase-admin:9.7.0'
+
 	// Test
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
 	testImplementation 'org.springframework.security:spring-security-test'
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
+	implementation 'it.ozimov:embedded-redis:0.7.3'
+	runtimeOnly 'com.h2database:h2'
+	testImplementation 'org.assertj:assertj-core:3.27.6'
+	implementation 'net.datafaker:datafaker:2.5.3'
 }
 
 tasks.named('test') {
 	useJUnitPlatform()
 }
+
+test {
+	testLogging {
+		showStandardStreams = true
+	}
+}

lombock.config

@@ -0,0 +1 @@
+lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier

scripts/deploy.sh

@@ -2,28 +2,75 @@
 
 cd /home/ubuntu/app
 
+# Redis 컨테이너 실행 여부 확인
+REDIS_CONTAINER_STATUS=$(docker ps | grep redis)
+if [ -z "$REDIS_CONTAINER_STATUS" ]; then
+  echo "Redis 컨테이너가 실행 중이지 않습니다"
+  echo ">>> Pulling Redis image"
+  docker compose -f docker-compose.redis.yml pull redis
+  echo ">>> Starting Redis container"
+  docker compose -f docker-compose.redis.yml up -d redis
+else
+  echo "Redis 컨테이너가 이미 실행 중입니다."
+fi
+
+
 DOCKER_APP_NAME=spring
 
-# 실행중인 blue가 있는지
-EXIST_BLUE=$(docker-compose -p ${DOCKER_APP_NAME}-blue -f docker-compose.blue.yml ps | grep running)
+# blue 컨테이너 실행 여부 확인
+BLUE_CONTAINER_RUNNING=$(docker-compose -p ${DOCKER_APP_NAME}-blue -f docker-compose.blue.yml ps -q | xargs docker inspect -f '{{.State.Running}}')
 
-# green이 실행중이면 blue up
-if [ -z "$EXIST_BLUE" ]; then
-	echo "blue up"
+# 컨테이너 스위칭
+if [ "$BLUE_CONTAINER_RUNNING" != "true" ]; then
+	echo "[blue up]"
 	docker-compose -p ${DOCKER_APP_NAME}-blue -f docker-compose.blue.yml up -d --build
 
-	sleep 30
-
-	docker-compose -p ${DOCKER_APP_NAME}-green -f docker-compose.green.yml down
-	docker image prune -af # 사용하지 않는 이미지 삭제
+  ACTIVE_ENV="blue"
+  STANDBY_ENV="green"
+  ACTIVE_PORT="8081"
 
-# blue가 실행중이면 green up
 else
-	echo "green up"
+	echo "[green up]"
 	docker-compose -p ${DOCKER_APP_NAME}-green -f docker-compose.green.yml up -d --build
 
-	sleep 30
+  ACTIVE_ENV="green"
+  STANDBY_ENV="blue"
+  ACTIVE_PORT="8082"
+
+fi
+
+
+# 헬스체크
+MAX_RETRIES=30
+RETRY_INTERVAL=2
+HEALTH_CHECK_URL="http://localhost:$ACTIVE_PORT/actuator/health"
+ACTIVE_HEALTH_CHECK_PASSED=false
+
+echo "Waiting for application to be ready..."
+for i in $(seq 1 $MAX_RETRIES); do
+  if curl -s "$HEALTH_CHECK_URL" | grep -q "UP"; then
+    echo "[Application is ready]"
+    ACTIVE_HEALTH_CHECK_PASSED=true
+    break
+
+  fi
+  echo "Waiting... ($i/$MAX_RETRIES)"
+  sleep $RETRY_INTERVAL
+
+done
+
+# 새로운 컨테이너가 제대로 떴는지 확인
+if [ "$ACTIVE_HEALTH_CHECK_PASSED" = "true" ]; then
+  # 이전 컨테이너 종료
+	docker-compose -p ${DOCKER_APP_NAME}-${STANDBY_ENV} -f docker-compose.${STANDBY_ENV}.yml down
+  docker image prune -af
+  echo "[Down] $STANDBY_ENV Down"
+
+else
+  echo "Health check failed after $MAX_RETRIES attempts"
+  # 새 컨테이너 종료
+  docker-compose -p ${DOCKER_APP_NAME}-${ACTIVE_ENV} -f docker-compose.${ACTIVE_ENV}.yml down
+  # 디스코드 알림
+  sudo ./discord_${ACTIVE_ENV}.sh
 
-	docker-compose -p ${DOCKER_APP_NAME}-blue -f docker-compose.blue.yml down
-	docker image prune -af
 fi

src/main/java/com/example/mohago_nocar/MohagoNocarApplication.java

@@ -2,7 +2,9 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 
+@EnableJpaAuditing
 @SpringBootApplication
 public class MohagoNocarApplication {
 

src/main/java/com/example/mohago_nocar/course/application/CourseErrorCode.java

@@ -0,0 +1,20 @@
+package com.example.mohago_nocar.course.application;
+
+import com.example.mohago_nocar.global.common.exception.Status;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import org.springframework.http.HttpStatus;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public enum CourseErrorCode implements Status {
+    TRAVEL_COURSE_OPTIMIZATION_INCOMPLETE(HttpStatus.BAD_REQUEST, "TRAVEL_COURSE_OPTIMIZATION_INCOMPLETE", "여행 코스 최적화가 완료되지 않았습니다.")
+    ;
+
+
+    private final HttpStatus httpStatus;
+    private final String code;
+    private final String message;
+
+}

src/main/java/com/example/mohago_nocar/course/application/course/TravelCourseConverter.java

@@ -0,0 +1,68 @@
+package com.example.mohago_nocar.course.application.course;
+
+import com.example.mohago_nocar.course.application.dto.*;
+import com.example.mohago_nocar.course.application.dto.RouteStepDto.LocationDto;
+import com.example.mohago_nocar.course.domain.model.routeStep.RouteStep;
+import com.example.mohago_nocar.course.domain.model.travelSpot.TravelSpot;
+import com.example.mohago_nocar.plan.domain.model.Location;
+import com.example.mohago_nocar.transit.domain.model.BusPath;
+import com.example.mohago_nocar.transit.domain.model.SubwayPath;
+import com.example.mohago_nocar.transit.domain.model.WalkPath;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class TravelCourseConverter {
+
+    public static RouteStepDto convertToRouteStepDto(
+            final TravelSpot origin,
+            final TravelSpot destination,
+            final RouteStep step
+    ){
+        return new RouteStepDto(
+                step.getTimeTakenMin(),
+                step.getDistanceKm(),
+                convertToLocationDto(origin),
+                convertToLocationDto(destination),
+                convertToSubPathDtos(step));
+    }
+
+    private static List<SubPathDto> convertToSubPathDtos(RouteStep step) {
+        return step.getDetailPaths().stream()
+                .map(path ->{
+                    if (path instanceof WalkPath walk) {
+                        return new WalkSubPathDto(walk.getDistanceKm(), walk.getTimeTakenMin(),
+                                walk.getPathType().name());
+                    }
+
+                    if (path instanceof BusPath bus) {
+                        return new BusSubPathDto(bus.getDistanceKm(), bus.getTimeTakenMin(),
+                                bus.getPathType().name(), bus.getBusNo(), bus.getBusType(),
+                                bus.getStartName(), bus.getStartCoordinate().getLongitude(), bus.getStartCoordinate().getLatitude(),
+                                bus.getEndName(), bus.getEndCoordinate().getLongitude(), bus.getEndCoordinate().getLatitude());
+                    }
+
+                    if (path instanceof SubwayPath subway) {
+                        return new SubwaySubPathDto(
+                                subway.getDistanceKm(), subway.getTimeTakenMin(),
+                                subway.getPathType().name(), subway.getSubwayLineName(),
+                                subway.getStartName(), subway.getStartCoordinate().getLongitude(), subway.getStartCoordinate().getLatitude(),
+                                subway.getEndName(), subway.getEndCoordinate().getLongitude(), subway.getEndCoordinate().getLatitude()
+                        );
+                    }
+
+                    throw new IllegalArgumentException("지원하지 않는 경로 유형입니다.");
+                })
+                .collect(Collectors.toList());
+    }
+
+    private static LocationDto convertToLocationDto(TravelSpot origin) {
+        Location location = origin.getLocation();
+        return LocationDto.builder()
+                .name(location.getName())
+                .latitude(location.getCoordinate().getLatitude())
+                .longitude(location.getCoordinate().getLongitude())
+                .build();
+    }
+
+}

src/main/java/com/example/mohago_nocar/course/application/course/TravelCourseEventHandler.java

@@ -0,0 +1,71 @@
+package com.example.mohago_nocar.course.application.course;
+
+import com.example.mohago_nocar.course.domain.event.TravelCourseOptimizedEvent;
+import com.example.mohago_nocar.course.domain.model.course.TravelCourseCompletionMessage;
+import com.example.mohago_nocar.course.domain.model.course.TravelCourseOptimizedEventHandleHistory;
+import com.example.mohago_nocar.course.domain.model.course.TravelCourseStatus;
+import com.example.mohago_nocar.course.domain.repository.TravelCourseOptimizedEventHandleHistoryRepository;
+import com.example.mohago_nocar.course.domain.service.TravelCourseUseCase;
+import com.example.mohago_nocar.global.notification.application.user.UserNotificationDto;
+import com.example.mohago_nocar.global.notification.application.user.UserNotificationOutboxService;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Map;
+
+@Component
+@Slf4j
+@RequiredArgsConstructor
+public class TravelCourseEventHandler {
+
+    private final TravelCourseUseCase travelCourseUseCase;
+    private final TravelCourseOptimizedEventHandleHistoryRepository handleHistoryRepository;
+    private final UserNotificationOutboxService notificationOutboxService;
+
+    @Transactional
+    public void handleEvent(TravelCourseOptimizedEvent event) {
+        travelCourseUseCase.generateTransitRoute(event.getTravelCourseId());
+        processSuccessEvent(event);
+    }
+
+    private void processSuccessEvent(TravelCourseOptimizedEvent event) {
+        travelCourseUseCase.updateUncompletedCourseStatus(event.getTravelCourseId(), TravelCourseStatus.SUCCEEDED);
+        UserNotificationDto notificationDto = createNotificationMessage(event, true);
+        notificationOutboxService.save(notificationDto);
+    }
+
+    @Transactional
+    public void processFailEvent(TravelCourseOptimizedEvent event) {
+        travelCourseUseCase.updateUncompletedCourseStatus(event.getTravelCourseId(), TravelCourseStatus.FAILED);
+        UserNotificationDto notificationDto = createNotificationMessage(event, false);
+        notificationOutboxService.save(notificationDto);
+    }
+
+    private UserNotificationDto createNotificationMessage(TravelCourseOptimizedEvent event, boolean isSuccess) {
+        TravelCourseCompletionMessage message = isSuccess ?
+                TravelCourseCompletionMessage.SUCCESS : TravelCourseCompletionMessage.FAILURE;
+
+        return new UserNotificationDto(
+                message.getTitle(),
+                message.getBody(),
+                event.getAnonymousUserId(),
+                Map.of("travelCourseId", String.valueOf(event.getTravelCourseId()))
+        );
+    }
+
+    public boolean hasHandleHistory(Long travelCourseId) {
+        TravelCourseOptimizedEventHandleHistory history = TravelCourseOptimizedEventHandleHistory.of(travelCourseId);
+
+        try {
+            handleHistoryRepository.save(history);
+        } catch (DataIntegrityViolationException e) {
+            return true;
+        }
+
+        return false;
+    }
+
+}