Merge pull request #53 from Nexters/feat/42-chunk-upload

feat: 영상 청크 업로드 기능 구현

Author: eric-jy-park

.gitignore

@@ -41,3 +41,5 @@ out/
 climbup-db-data
 climbup-redis-data
 .claude
+
+.serena/

src/main/java/com/climbup/climbup/attempt/controller/AttemptController.java

@@ -3,13 +3,16 @@
 
 import com.climbup.climbup.attempt.dto.request.CreateAttemptRequest;
 import com.climbup.climbup.attempt.dto.response.CreateAttemptResponse;
+import com.climbup.climbup.attempt.repository.UserMissionAttemptRepository;
 import com.climbup.climbup.attempt.service.AttemptService;
 import com.climbup.climbup.attempt.upload.dto.request.RouteMissionUploadChunkRequest;
 import com.climbup.climbup.attempt.upload.dto.request.RouteMissionUploadSessionInitializeRequest;
 import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadChunkResponse;
 import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadSessionFinalizeResponse;
 import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadSessionInitializeResponse;
 import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadStatusResponse;
+import com.climbup.climbup.attempt.upload.entity.UploadSession;
+import com.climbup.climbup.attempt.upload.repository.UploadSessionRepository;
 import com.climbup.climbup.auth.util.SecurityUtil;
 import com.climbup.climbup.common.dto.ApiResult;
 import com.climbup.climbup.recommendation.dto.response.RouteMissionRecommendationResponse;
@@ -39,6 +42,7 @@ public class AttemptController {
 
     private final AttemptService attemptService;
     private final RecommendationService recommendationService;
+    private final UploadSessionRepository uploadSessionRepository;
 
 
     @Operation(summary = "도전한 루트미션과 비슷한 난이도의 루트미션 리스트 불러오기", description = "도전한 루트미션과 비슷한 난이도의 루트미션 리스트를 받아보기", security = @SecurityRequirement(name = "bearerAuth"))
@@ -120,7 +124,8 @@ public ResponseEntity<ApiResult<CreateAttemptResponse>> createAttempt(
     public ResponseEntity<ApiResult<RouteMissionUploadStatusResponse>> getRouteMissionUploadStatus(
             @PathVariable(name = "attemptId") Long attemptId
     ) {
-        return ResponseEntity.ok(ApiResult.success(RouteMissionUploadStatusResponse.builder().build()));
+        RouteMissionUploadStatusResponse response = attemptService.getAttemptUploadStatus(attemptId);
+        return ResponseEntity.ok(ApiResult.success(response));
     }
 
 
@@ -131,7 +136,9 @@ public ResponseEntity<ApiResult<RouteMissionUploadSessionInitializeResponse>> in
             @PathVariable(name = "attemptId") Long attemptId,
             @Valid @RequestBody RouteMissionUploadSessionInitializeRequest request
     ) {
-        return ResponseEntity.ok(ApiResult.success(RouteMissionUploadSessionInitializeResponse.builder().build()));
+        RouteMissionUploadSessionInitializeResponse response = attemptService.initializeAttemptUploadSession(attemptId, request);
+
+        return ResponseEntity.ok(ApiResult.success(response));
     }
 
 
@@ -143,7 +150,10 @@ public ResponseEntity<ApiResult<RouteMissionUploadChunkResponse>> uploadRouteMis
             @PathVariable(name = "uploadId") UUID uploadId,
             @Valid @RequestBody RouteMissionUploadChunkRequest request
             ) {
-        return ResponseEntity.ok(ApiResult.success(RouteMissionUploadChunkResponse.builder().build()));
+
+        RouteMissionUploadChunkResponse response = attemptService.uploadChunk(uploadId, request);
+
+        return ResponseEntity.ok(ApiResult.success(response));
     }
 
 
@@ -154,6 +164,7 @@ public ResponseEntity<ApiResult<RouteMissionUploadSessionFinalizeResponse>> fina
             @PathVariable(name = "attemptId") Long attemptId,
             @PathVariable(name = "uploadId") UUID uploadId
     ) {
-        return ResponseEntity.ok(ApiResult.success(RouteMissionUploadSessionFinalizeResponse.builder().build()));
+        RouteMissionUploadSessionFinalizeResponse response = attemptService.finalizeUploadSession(uploadId);
+        return ResponseEntity.ok(ApiResult.success(response));
     }
 }

src/main/java/com/climbup/climbup/attempt/entity/UserMissionAttempt.java

@@ -1,5 +1,6 @@
 package com.climbup.climbup.attempt.entity;
 
+import com.climbup.climbup.attempt.upload.entity.UploadSession;
 import com.climbup.climbup.common.entity.BaseEntity;
 import com.climbup.climbup.route.entity.RouteMission;
 import com.climbup.climbup.session.entity.UserSession;
@@ -36,6 +37,10 @@ public class UserMissionAttempt extends BaseEntity {
     @JoinColumn(name = "mission_id", nullable = false)
     private RouteMission mission;
 
+    @OneToOne(cascade = CascadeType.ALL)
+    @JoinColumn(name = "upload_id")
+    private UploadSession upload;
+
     @Column(name = "success", nullable = false)
     private Boolean success;
 

src/main/java/com/climbup/climbup/attempt/exception/UploadSessionAlreadyExistsException.java

@@ -0,0 +1,10 @@
+package com.climbup.climbup.attempt.exception;
+
+import com.climbup.climbup.common.exception.BusinessException;
+import com.climbup.climbup.common.exception.ErrorCode;
+
+public class UploadSessionAlreadyExistsException extends BusinessException {
+    public UploadSessionAlreadyExistsException() {
+        super(ErrorCode.UPLOAD_SESSION_ALREADY_EXISTS);
+    }
+}

src/main/java/com/climbup/climbup/attempt/exception/UploadSessionChunkAlreadyExistsException.java

@@ -0,0 +1,10 @@
+package com.climbup.climbup.attempt.exception;
+
+import com.climbup.climbup.common.exception.BusinessException;
+import com.climbup.climbup.common.exception.ErrorCode;
+
+public class UploadSessionChunkAlreadyExistsException extends BusinessException {
+  public UploadSessionChunkAlreadyExistsException() {
+    super(ErrorCode.UPLOAD_SESSION_CHUNK_ALREADY_EXISTS);
+  }
+}

src/main/java/com/climbup/climbup/attempt/exception/UploadSessionChunkIncompleteException.java

@@ -0,0 +1,10 @@
+package com.climbup.climbup.attempt.exception;
+
+import com.climbup.climbup.common.exception.BusinessException;
+import com.climbup.climbup.common.exception.ErrorCode;
+
+public class UploadSessionChunkIncompleteException extends BusinessException {
+    public UploadSessionChunkIncompleteException() {
+        super(ErrorCode.UPLOAD_SESSION_CHUNK_INCOMPLETE);
+    }
+}

src/main/java/com/climbup/climbup/attempt/exception/UploadSessionNotFoundException.java

@@ -0,0 +1,10 @@
+package com.climbup.climbup.attempt.exception;
+
+import com.climbup.climbup.common.exception.BusinessException;
+import com.climbup.climbup.common.exception.ErrorCode;
+
+public class UploadSessionNotFoundException extends BusinessException {
+    public UploadSessionNotFoundException() {
+        super(ErrorCode.UPLOAD_SESSION_NOT_FOUND);
+    }
+}

src/main/java/com/climbup/climbup/attempt/repository/UserMissionAttemptRepository.java

@@ -6,9 +6,14 @@
 import org.springframework.data.repository.query.Param;
 
 import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
 
 public interface UserMissionAttemptRepository extends JpaRepository<UserMissionAttempt, Long> {
 
     @Query("SELECT uma FROM UserMissionAttempt uma WHERE uma.user.id = :userId AND uma.session.id = :sessionId")
     List<UserMissionAttempt> findByUserIdAndSessionId(@Param("userId") Long userId, @Param("sessionId") Long sessionId);
+
+    @Query("SELECT uma FROM UserMissionAttempt uma WHERE uma.upload.id = :uploadId")
+    Optional<UserMissionAttempt> findByUploadId(@Param("uploadId") UUID uploadId);
 }

src/main/java/com/climbup/climbup/attempt/service/AttemptService.java

@@ -2,8 +2,23 @@
 
 import com.climbup.climbup.attempt.dto.request.CreateAttemptRequest;
 import com.climbup.climbup.attempt.dto.response.CreateAttemptResponse;
+import com.climbup.climbup.attempt.upload.dto.request.RouteMissionUploadChunkRequest;
+import com.climbup.climbup.attempt.upload.dto.request.RouteMissionUploadSessionInitializeRequest;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadChunkResponse;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadSessionFinalizeResponse;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadSessionInitializeResponse;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadStatusResponse;
 
-public interface AttemptService {
+import java.util.UUID;
 
+public interface AttemptService {
     CreateAttemptResponse createAttempt(Long userId, CreateAttemptRequest request);
+
+    RouteMissionUploadStatusResponse getAttemptUploadStatus(Long attemptId);
+
+    RouteMissionUploadSessionInitializeResponse initializeAttemptUploadSession(Long attemptId, RouteMissionUploadSessionInitializeRequest request);
+
+    RouteMissionUploadChunkResponse uploadChunk(UUID uploadId, RouteMissionUploadChunkRequest request);
+
+    RouteMissionUploadSessionFinalizeResponse finalizeUploadSession(UUID uploadId);
 }

src/main/java/com/climbup/climbup/attempt/service/AttemptServiceImpl.java

@@ -4,7 +4,20 @@
 import com.climbup.climbup.attempt.dto.request.CreateAttemptRequest;
 import com.climbup.climbup.attempt.dto.response.CreateAttemptResponse;
 import com.climbup.climbup.attempt.entity.UserMissionAttempt;
+import com.climbup.climbup.attempt.exception.*;
 import com.climbup.climbup.attempt.repository.UserMissionAttemptRepository;
+import com.climbup.climbup.attempt.upload.dto.request.RouteMissionUploadChunkRequest;
+import com.climbup.climbup.attempt.upload.dto.request.RouteMissionUploadSessionInitializeRequest;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadChunkResponse;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadSessionFinalizeResponse;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadSessionInitializeResponse;
+import com.climbup.climbup.attempt.upload.dto.response.RouteMissionUploadStatusResponse;
+import com.climbup.climbup.attempt.upload.entity.UploadSession;
+import com.climbup.climbup.attempt.upload.entity.Chunk;
+import com.climbup.climbup.attempt.upload.enums.UploadStatus;
+import com.climbup.climbup.attempt.upload.repository.UploadSessionRepository;
+import com.climbup.climbup.attempt.upload.repository.ChunkRepository;
+import com.climbup.climbup.common.exception.CommonBusinessException;
 import com.climbup.climbup.common.exception.ErrorCode;
 import com.climbup.climbup.common.exception.ValidationException;
 import com.climbup.climbup.route.entity.RouteMission;
@@ -23,6 +36,12 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+import java.io.*;
+import java.nio.file.*;
+
 @Service
 @RequiredArgsConstructor
 @Slf4j
@@ -34,6 +53,61 @@ public class AttemptServiceImpl implements AttemptService {
     private final UserRepository userRepository;
     private final UserSessionRepository sessionRepository;
     private final SRHistoryRepository srHistoryRepository;
+    private final UploadSessionRepository uploadSessionRepository;
+    private final ChunkRepository chunkRepository;
+
+
+    private Path getUploadSessionDirectory(UUID uploadId) {
+        return Paths.get("uploads", uploadId.toString(), "chunks");
+    }
+
+    private void ensureDirectoryExists(Path uploadDirectory) {
+        try {
+            Files.createDirectories(uploadDirectory);
+        } catch (IOException e) {
+            throw new CommonBusinessException(ErrorCode.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    private Path getChunkFilePath(UUID uploadId, int chunkIndex) {
+        return Paths.get("uploads", uploadId.toString(), "chunks", String.valueOf(chunkIndex));
+    }
+
+    private String combineChunks(UploadSession uploadSession)
+    {
+        String fileName = uploadSession.getFileName() + "." + uploadSession.getFileType();
+        Path finalFilePath = Paths.get("uploads", uploadSession.getId().toString(), fileName);
+        ensureDirectoryExists(finalFilePath.getParent());
+
+        List<Chunk> sortedChunks = uploadSession.getChunks().stream()
+                .sorted(Comparator.comparing(Chunk::getChunkIndex))
+                .toList();
+
+        try (FileOutputStream fos = new FileOutputStream(finalFilePath.toFile());
+             BufferedOutputStream bos = new BufferedOutputStream(fos)) {
+
+            for (Chunk chunk : sortedChunks) {
+                Path chunkPath = Paths.get(chunk.getFilePath());
+                byte[] chunkData = Files.readAllBytes(chunkPath);
+                bos.write(chunkData);
+            }
+            bos.flush();
+        } catch (IOException e) {
+            log.error(e.toString());
+            throw new CommonBusinessException(ErrorCode.INTERNAL_SERVER_ERROR);
+        }
+
+        for (Chunk chunk : sortedChunks) {
+            try {
+                Files.deleteIfExists(Paths.get(chunk.getFilePath()));
+            } catch (IOException e) {
+                log.warn("Failed to delete chunk file: {}", chunk.getFilePath(), e);
+            }
+        }
+
+        return finalFilePath.toString();
+    }
+
 
     @Transactional
     public CreateAttemptResponse createAttempt(Long userId, CreateAttemptRequest request) {
@@ -98,4 +172,119 @@ public CreateAttemptResponse createAttempt(Long userId, CreateAttemptRequest req
                 .currentSr(currentSr)
                 .build();
     }
+
+    @Override
+    @Transactional(readOnly = true)
+    public RouteMissionUploadStatusResponse getAttemptUploadStatus(Long attemptId) {
+        UserMissionAttempt attempt = attemptRepository.findById(attemptId).orElseThrow(AttemptNotFoundException::new);
+
+        var uploadSession = attempt.getUpload();
+
+        if(uploadSession == null) {
+            throw new UploadSessionNotFoundException();
+        }
+
+        return RouteMissionUploadStatusResponse.toDto(uploadSession);
+    }
+
+    @Override
+    @Transactional
+    public RouteMissionUploadSessionInitializeResponse initializeAttemptUploadSession(Long attemptId, RouteMissionUploadSessionInitializeRequest request) {
+        UserMissionAttempt attempt = attemptRepository.findById(attemptId).orElseThrow(AttemptNotFoundException::new);
+
+        if(attempt.getUpload() != null) {
+            throw new UploadSessionAlreadyExistsException();
+        }
+
+        UploadSession uploadSession = UploadSession.builder().status(UploadStatus.NOT_STARTED).chunkLength(request.getChunkLength()).chunkSize(request.getChunkSize()).fileSize(request.getFileSize()).fileName(request.getFileName()).fileType(request.getFileType()).build();
+
+        uploadSession = uploadSessionRepository.save(uploadSession);
+
+        attempt.setUpload(uploadSession);
+
+        attemptRepository.save(attempt);
+
+        return RouteMissionUploadSessionInitializeResponse.builder().uploadId(uploadSession.getId()).build();
+    }
+
+    @Override
+    @Transactional
+    public RouteMissionUploadChunkResponse uploadChunk(UUID uploadId, RouteMissionUploadChunkRequest request) {
+
+        UploadSession uploadSession = uploadSessionRepository.findById(uploadId).orElseThrow(UploadSessionNotFoundException::new);
+
+        if(uploadSession.hasChunk(request.getIndex())) {
+            throw new UploadSessionChunkAlreadyExistsException();
+        }
+
+        try {
+            Path sessionDir = getUploadSessionDirectory(uploadId);
+            ensureDirectoryExists(sessionDir);
+
+            Path chunkFilePath = getChunkFilePath(uploadId, request.getIndex());
+            Files.write(chunkFilePath, request.getChunk());
+
+            Chunk chunk = new Chunk();
+            chunk.setChunkIndex(request.getIndex());
+            chunk.setChunkSize((long) request.getChunk().length);
+            chunk.setCompleted(true);
+            chunk.setFilePath(chunkFilePath.toString());
+
+            uploadSession.addChunk(chunk);
+
+            String chunkName = String.format("chunk_%d_%s", request.getIndex(), uploadSession.getFileName());
+            chunk.setName(chunkName);
+
+            chunkRepository.save(chunk);
+
+
+        } catch (IOException e) {
+            log.error("Failed to store chunk {} for upload session {}", request.getIndex(), uploadId, e);
+            throw new UploadSessionChunkIncompleteException();
+        }
+
+        if (uploadSession.getStatus() == UploadStatus.NOT_STARTED) {
+            uploadSession.setStatus(UploadStatus.IN_PROGRESS);
+            uploadSessionRepository.save(uploadSession);
+        }
+
+
+        return RouteMissionUploadChunkResponse.builder()
+                .index(request.getIndex())
+                .totalChunkReceived(uploadSession.getReceivedChunkCount().intValue())
+                .totalChunkExpected(uploadSession.getChunkLength())
+                .build();
+    }
+
+    @Override
+    @Transactional
+    public RouteMissionUploadSessionFinalizeResponse finalizeUploadSession(UUID uploadId) {
+        UploadSession uploadSession = uploadSessionRepository.findById(uploadId).orElseThrow(UploadSessionNotFoundException::new);
+
+        long receivedChunks = uploadSession.getReceivedChunkCount();
+        int expectedChunks = uploadSession.getChunkLength();
+        
+        if (receivedChunks != expectedChunks) {
+            throw new UploadSessionChunkIncompleteException();
+        }
+
+        String finalVideoPath = combineChunks(uploadSession);
+
+        uploadSession.setStatus(UploadStatus.FINISHED);
+        uploadSessionRepository.save(uploadSession);
+
+        log.info("video saved in {}", finalVideoPath);
+
+        // upload the video to NCP storage
+
+        UserMissionAttempt attempt = attemptRepository.findByUploadId(uploadId)
+                .orElseThrow(AttemptNotFoundException::new);
+
+        attemptRepository.save(attempt);
+
+        return RouteMissionUploadSessionFinalizeResponse.builder()
+                .fileName(uploadSession.getFileName())
+                .build();
+    }
+
 }