파일 메니저 api 반영

src/main/java/com/kamco/cd/training/filemanager/FileManagerApiController.java

@@ -144,7 +144,7 @@ public class FileManagerApiController {
       })
   @GetMapping("/model-path/{modelUuid}")
   public ApiResponseDto<FileManagerDto.ModelFilePathRes> getModelFilePath(
-      @Parameter(description = "모델 UUID", example = "123e4567-e89b-12d3-a456-426614174000")
+      @Parameter(description = "모델 UUID", example = "df284755-c0b7-4070-bfee-ef554e8d0fe4")
           @PathVariable
           UUID modelUuid) {
 
@@ -170,7 +170,7 @@ public class FileManagerApiController {
       })
   @GetMapping("/dataset-path/{datasetUuid}")
   public ApiResponseDto<FileManagerDto.DatasetFilePathRes> getDatasetFilePath(
-      @Parameter(description = "데이터셋 UUID", example = "123e4567-e89b-12d3-a456-426614174001")
+      @Parameter(description = "데이터셋 UUID", example = "037b09a0-b315-4e2e-b88d-b9011f9eaa15")
           @PathVariable
           UUID datasetUuid) {
 
@@ -198,7 +198,7 @@ public class FileManagerApiController {
   public ApiResponseDto<FileManagerDto.DirectoryCapacityRes> checkDirectoryCapacity(
       @Parameter(
               description = "디렉토리 경로",
-              example = "/home/kcomu/data/request/123e4567-e89b-12d3-a456-426614174001")
+              example = "/home/kcomu/data/request/037b09a0-b315-4e2e-b88d-b9011f9eaa15")
           @RequestParam
           String directoryPath) {
 
@@ -233,4 +233,27 @@ public class FileManagerApiController {
         fileManagerService.getModelsExecutionStatus();
     return ApiResponseDto.ok(response);
   }
+
+  @Operation(
+      summary = "저장공간 정보 조회",
+      description =
+          "/home/kcomu/data 경로의 사용 중인 용량, 전체 디스크 용량, 남은 저장공간을 조회합니다. "
+              + "파라미터 없이 호출하면 자동으로 /home/kcomu/data 경로 정보를 반환합니다.")
+  @ApiResponses(
+      value = {
+        @ApiResponse(
+            responseCode = "200",
+            description = "조회 성공",
+            content =
+                @Content(
+                    mediaType = "application/json",
+                    schema = @Schema(implementation = FileManagerDto.StorageSpaceRes.class))),
+        @ApiResponse(responseCode = "500", description = "서버 오류", content = @Content)
+      })
+  @GetMapping("/storage-space")
+  public ApiResponseDto<FileManagerDto.StorageSpaceRes> getStorageSpaceInfo() {
+
+    FileManagerDto.StorageSpaceRes response = fileManagerService.getStorageSpaceInfo();
+    return ApiResponseDto.ok(response);
+  }
 }

src/main/java/com/kamco/cd/training/filemanager/dto/FileManagerDto.java

@@ -138,17 +138,17 @@ public class FileManagerDto {
   @AllArgsConstructor
   @Schema(description = "모델 파일 경로 정보 응답")
   public static class ModelFilePathRes {
-    @Schema(description = "모델 UUID", example = "123e4567-e89b-12d3-a456-426614174000")
+    @Schema(description = "모델 UUID", example = "df284755-c0b7-4070-bfee-ef554e8d0fe4")
     private String modelUuid;
 
     @Schema(
         description = "요청 경로 (심볼릭 링크 디렉토리)",
-        example = "/home/kcomu/data/tmp/123e4567-e89b-12d3-a456-426614174000")
+        example = "/home/kcomu/data/tmp/AE366F3076504FACBF12106986202AB5")
     private String requestPath;
 
     @Schema(
         description = "응답 경로 (모델 결과 저장)",
-        example = "/home/kcomu/data/response/123e4567-e89b-12d3-a456-426614174000")
+        example = "/home/kcomu/data/response/df284755-c0b7-4070-bfee-ef554e8d0fe4")
     private String responsePath;
 
     @Schema(description = "요청 경로 파일 목록")
@@ -164,12 +164,12 @@ public class FileManagerDto {
   @AllArgsConstructor
   @Schema(description = "데이터셋 파일 경로 정보 응답")
   public static class DatasetFilePathRes {
-    @Schema(description = "데이터셋 UUID", example = "123e4567-e89b-12d3-a456-426614174001")
+    @Schema(description = "데이터셋 UUID", example = "037b09a0-b315-4e2e-b88d-b9011f9eaa15")
     private String datasetUuid;
 
     @Schema(
         description = "데이터셋 경로",
-        example = "/home/kcomu/data/request/123e4567-e89b-12d3-a456-426614174001")
+        example = "/home/kcomu/data/request/037b09a0-b315-4e2e-b88d-b9011f9eaa15")
     private String datasetPath;
 
     @Schema(description = "데이터셋 파일 목록")
@@ -232,4 +232,47 @@ public class FileManagerDto {
     @Schema(description = "현재 실행 중인 모델 개수", example = "2")
     private Integer runningCount;
   }
+
+  @Data
+  @Builder
+  @NoArgsConstructor
+  @AllArgsConstructor
+  @Schema(description = "저장공간 정보 응답 (남은 공간 포함)")
+  public static class StorageSpaceRes {
+    @Schema(description = "디렉토리 경로", example = "/home/kcomu/data")
+    private String directoryPath;
+
+    @Schema(description = "파일 개수", example = "1234")
+    private Integer fileCount;
+
+    @Schema(description = "디렉토리 개수", example = "56")
+    private Integer directoryCount;
+
+    @Schema(description = "사용 중인 용량 (bytes)", example = "10485760000")
+    private Long usedSize;
+
+    @Schema(description = "사용 중인 용량 (읽기 쉬운 형식)", example = "9.77 GB")
+    private String usedSizeFormatted;
+
+    @Schema(description = "전체 디스크 용량 (bytes)", example = "1000000000000")
+    private Long totalDiskSpace;
+
+    @Schema(description = "전체 디스크 용량 (읽기 쉬운 형식)", example = "931.32 GB")
+    private String totalDiskSpaceFormatted;
+
+    @Schema(description = "남은 저장공간 (bytes)", example = "500000000000")
+    private Long freeSpace;
+
+    @Schema(description = "남은 저장공간 (읽기 쉬운 형식)", example = "465.66 GB")
+    private String freeSpaceFormatted;
+
+    @Schema(description = "사용 가능한 공간 (bytes)", example = "480000000000")
+    private Long usableSpace;
+
+    @Schema(description = "사용 가능한 공간 (읽기 쉬운 형식)", example = "447.03 GB")
+    private String usableSpaceFormatted;
+
+    @Schema(description = "디스크 사용률 (%)", example = "50.5")
+    private Double usagePercentage;
+  }
 }

src/main/java/com/kamco/cd/training/filemanager/service/FileManagerService.java

@@ -57,15 +57,38 @@ public class FileManagerService {
 
     boolean recursive = request.getRecursive() != null && request.getRecursive();
 
-    validatePath(targetPath);
+    // 경로 검증은 수행하되, 예외를 throw하지 않고 빈 데이터 반환
+    try {
+      validatePath(targetPath);
+    } catch (IllegalArgumentException e) {
+      log.debug("유효하지 않은 경로: {}", targetPath);
+      return FileManagerDto.ListFilesRes.builder()
+          .directoryPath(targetPath)
+          .files(new ArrayList<>())
+          .totalCount(0)
+          .totalSize(0L)
+          .build();
+    }
 
     Path directory = Paths.get(targetPath);
     if (!Files.exists(directory)) {
-      throw new IllegalArgumentException("디렉토리가 존재하지 않습니다: " + targetPath);
+      log.debug("디렉토리가 존재하지 않습니다: {}", targetPath);
+      return FileManagerDto.ListFilesRes.builder()
+          .directoryPath(targetPath)
+          .files(new ArrayList<>())
+          .totalCount(0)
+          .totalSize(0L)
+          .build();
     }
 
     if (!Files.isDirectory(directory)) {
-      throw new IllegalArgumentException("디렉토리 경로가 아닙니다: " + targetPath);
+      log.debug("디렉토리 경로가 아닙니다: {}", targetPath);
+      return FileManagerDto.ListFilesRes.builder()
+          .directoryPath(targetPath)
+          .files(new ArrayList<>())
+          .totalCount(0)
+          .totalSize(0L)
+          .build();
     }
 
     List<FileManagerDto.FileInfo> files = new ArrayList<>();
@@ -106,8 +129,13 @@ public class FileManagerService {
       }
 
     } catch (IOException e) {
-      log.error("파일 목록 조회 중 오류 발생: {}", targetPath, e);
+      log.debug("파일 목록 조회 중 오류 발생: {}", targetPath, e);
-      throw new RuntimeException("파일 목록 조회에 실패했습니다: " + e.getMessage());
+      return FileManagerDto.ListFilesRes.builder()
+          .directoryPath(targetPath)
+          .files(new ArrayList<>())
+          .totalCount(0)
+          .totalSize(0L)
+          .build();
     }
 
     return FileManagerDto.ListFilesRes.builder()
@@ -132,11 +160,18 @@ public class FileManagerService {
 
     for (String filePath : request.getFilePaths()) {
       try {
-        validatePath(filePath);
+        try {
+          validatePath(filePath);
+        } catch (IllegalArgumentException e) {
+          log.debug("유효하지 않은 경로: {}", filePath);
+          failedFiles.add(filePath + " (유효하지 않은 경로)");
+          continue;
+        }
+
         Path path = Paths.get(filePath);
 
         if (!Files.exists(path)) {
-          log.warn("삭제하려는 파일이 존재하지 않습니다: {}", filePath);
+          log.debug("삭제하려는 파일이 존재하지 않습니다: {}", filePath);
           failedFiles.add(filePath + " (파일이 존재하지 않음)");
           continue;
         }
@@ -164,7 +199,7 @@ public class FileManagerService {
         log.info("파일 삭제 성공: {}", filePath);
 
       } catch (Exception e) {
-        log.error("파일 삭제 실패: {}", filePath, e);
+        log.debug("파일 삭제 실패: {}", filePath, e);
         failedFiles.add(filePath + " (" + e.getMessage() + ")");
       }
     }
@@ -258,15 +293,33 @@ public class FileManagerService {
    * @return 모델 파일 경로 및 파일 목록
    */
   public FileManagerDto.ModelFilePathRes getModelFilePath(UUID modelUuid) {
-    // tb_model_master 테이블에서 모델 존재 여부 확인
+    // tb_model_master 테이블에서 모델 조회
-    modelMngRepository
+    ModelMasterEntity model = modelMngRepository.findByUuid(modelUuid).orElse(null);
-        .findByUuid(modelUuid)
-        .orElseThrow(() -> new IllegalArgumentException("모델을 찾을 수 없습니다: " + modelUuid));
 
-    // request_path: symbolic_link_dir + model_uuid
+    // 모델이 존재하지 않으면 빈 데이터 반환
-    String requestPath = symbolicLinkDir + "/" + modelUuid;
+    if (model == null) {
+      return FileManagerDto.ModelFilePathRes.builder()
+          .modelUuid(modelUuid.toString())
+          .requestPath(null)
+          .responsePath(null)
+          .requestFiles(new ArrayList<>())
+          .responseFiles(new ArrayList<>())
+          .build();
+    }
 
-    // response_path: response_dir + model_uuid
+    // request_path: tb_model_master.request_path 컬럼 값 사용
+    // request_path 컬럼에는 'AE366F3076504FACBF12106986202AB5' 형태의 값이 저장되어 있음
+    String requestPathFromDb = model.getRequestPath();
+    String requestPath;
+    if (requestPathFromDb != null && !requestPathFromDb.isEmpty()) {
+      // DB에 저장된 값이 있으면 symbolic_link_dir + request_path 조합
+      requestPath = symbolicLinkDir + "/" + requestPathFromDb;
+    } else {
+      // 없으면 기본값: symbolic_link_dir + model_uuid
+      requestPath = symbolicLinkDir + "/" + modelUuid;
+    }
+
+    // response_path: response_dir + model_uuid (UUID 사용)
     String responsePath = responseDir + "/" + modelUuid;
 
     // 파일 목록 조회
@@ -290,10 +343,16 @@ public class FileManagerService {
    */
   public FileManagerDto.DatasetFilePathRes getDatasetFilePath(UUID datasetUuid) {
     // tb_dataset 테이블에서 데이터셋 조회
-    DatasetEntity dataset =
+    DatasetEntity dataset = datasetRepository.findByUuid(datasetUuid).orElse(null);
-        datasetRepository
+
-            .findByUuid(datasetUuid)
+    // 데이터셋이 존재하지 않으면 빈 데이터 반환
-            .orElseThrow(() -> new IllegalArgumentException("데이터셋을 찾을 수 없습니다: " + datasetUuid));
+    if (dataset == null) {
+      return FileManagerDto.DatasetFilePathRes.builder()
+          .datasetUuid(datasetUuid.toString())
+          .datasetPath(null)
+          .files(new ArrayList<>())
+          .build();
+    }
 
     // dataset_path 컬럼이 있으면 사용, 없으면 request_dir + uuid 사용
     String datasetPath = dataset.getDatasetPath();
@@ -318,15 +377,41 @@ public class FileManagerService {
    * @return 디렉토리 용량 정보
    */
   public FileManagerDto.DirectoryCapacityRes checkDirectoryCapacity(String directoryPath) {
-    validatePath(directoryPath);
+    // 경로 검증은 수행하되, 예외를 throw하지 않고 빈 데이터 반환
+    try {
+      validatePath(directoryPath);
+    } catch (IllegalArgumentException e) {
+      log.debug("유효하지 않은 경로: {}", directoryPath);
+      return FileManagerDto.DirectoryCapacityRes.builder()
+          .directoryPath(directoryPath)
+          .fileCount(0)
+          .directoryCount(0)
+          .totalSize(0L)
+          .totalSizeFormatted("0 B")
+          .build();
+    }
 
     Path directory = Paths.get(directoryPath);
     if (!Files.exists(directory)) {
-      throw new IllegalArgumentException("디렉토리가 존재하지 않습니다: " + directoryPath);
+      log.debug("디렉토리가 존재하지 않습니다: {}", directoryPath);
+      return FileManagerDto.DirectoryCapacityRes.builder()
+          .directoryPath(directoryPath)
+          .fileCount(0)
+          .directoryCount(0)
+          .totalSize(0L)
+          .totalSizeFormatted("0 B")
+          .build();
     }
 
     if (!Files.isDirectory(directory)) {
-      throw new IllegalArgumentException("디렉토리 경로가 아닙니다: " + directoryPath);
+      log.debug("디렉토리 경로가 아닙니다: {}", directoryPath);
+      return FileManagerDto.DirectoryCapacityRes.builder()
+          .directoryPath(directoryPath)
+          .fileCount(0)
+          .directoryCount(0)
+          .totalSize(0L)
+          .totalSizeFormatted("0 B")
+          .build();
     }
 
     final long[] totalSize = {0};
@@ -353,8 +438,14 @@ public class FileManagerService {
             }
           });
     } catch (IOException e) {
-      log.error("디렉토리 용량 체크 중 오류 발생: {}", directoryPath, e);
+      log.debug("디렉토리 용량 체크 중 오류 발생: {}", directoryPath, e);
-      throw new RuntimeException("디렉토리 용량 체크에 실패했습니다: " + e.getMessage());
+      return FileManagerDto.DirectoryCapacityRes.builder()
+          .directoryPath(directoryPath)
+          .fileCount(0)
+          .directoryCount(0)
+          .totalSize(0L)
+          .totalSizeFormatted("0 B")
+          .build();
     }
 
     return FileManagerDto.DirectoryCapacityRes.builder()
@@ -444,19 +535,19 @@ public class FileManagerService {
 
     Path directory = Paths.get(directoryPath);
     if (!Files.exists(directory)) {
-      log.warn("디렉토리가 존재하지 않습니다: {}", directoryPath);
+      log.debug("디렉토리가 존재하지 않습니다: {}", directoryPath);
       return files;
     }
 
     if (!Files.isDirectory(directory)) {
-      log.warn("디렉토리 경로가 아닙니다: {}", directoryPath);
+      log.debug("디렉토리 경로가 아닙니다: {}", directoryPath);
       return files;
     }
 
     try (Stream<Path> stream = Files.list(directory)) {
       stream.forEach(path -> files.add(createFileInfo(path)));
     } catch (IOException e) {
-      log.error("파일 목록 조회 중 오류 발생: {}", directoryPath, e);
+      log.debug("파일 목록 조회 중 오류 발생: {}", directoryPath, e);
     }
 
     return files;
@@ -474,4 +565,130 @@ public class FileManagerService {
       return String.format("%.2f GB", size / (1024.0 * 1024.0 * 1024.0));
     }
   }
+
+  /**
+   * 저장공간 정보 조회 (남은 공간 포함) 고정 경로: /home/kcomu/data
+   *
+   * @return 저장공간 정보 (사용량, 남은 공간, 디스크 용량)
+   */
+  public FileManagerDto.StorageSpaceRes getStorageSpaceInfo() {
+    // 고정 경로: /home/kcomu/data
+    String directoryPath = "/home/kcomu/data";
+
+    Path directory = Paths.get(directoryPath);
+    if (!Files.exists(directory)) {
+      log.debug("디렉토리가 존재하지 않습니다: {}", directoryPath);
+      return FileManagerDto.StorageSpaceRes.builder()
+          .directoryPath(directoryPath)
+          .fileCount(0)
+          .directoryCount(0)
+          .usedSize(0L)
+          .usedSizeFormatted("0 B")
+          .totalDiskSpace(0L)
+          .totalDiskSpaceFormatted("0 B")
+          .freeSpace(0L)
+          .freeSpaceFormatted("0 B")
+          .usableSpace(0L)
+          .usableSpaceFormatted("0 B")
+          .usagePercentage(0.0)
+          .build();
+    }
+
+    if (!Files.isDirectory(directory)) {
+      log.debug("디렉토리 경로가 아닙니다: {}", directoryPath);
+      return FileManagerDto.StorageSpaceRes.builder()
+          .directoryPath(directoryPath)
+          .fileCount(0)
+          .directoryCount(0)
+          .usedSize(0L)
+          .usedSizeFormatted("0 B")
+          .totalDiskSpace(0L)
+          .totalDiskSpaceFormatted("0 B")
+          .freeSpace(0L)
+          .freeSpaceFormatted("0 B")
+          .usableSpace(0L)
+          .usableSpaceFormatted("0 B")
+          .usagePercentage(0.0)
+          .build();
+    }
+
+    // 디렉토리 사용량 계산 (재귀적으로 모든 파일 크기 합산)
+    final long[] usedSize = {0};
+    final int[] fileCount = {0};
+    final int[] directoryCount = {0};
+
+    try {
+      Files.walkFileTree(
+          directory,
+          new SimpleFileVisitor<>() {
+            @Override
+            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
+              usedSize[0] += attrs.size();
+              fileCount[0]++;
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
+              if (!dir.equals(directory)) {
+                directoryCount[0]++;
+              }
+              return FileVisitResult.CONTINUE;
+            }
+          });
+    } catch (IOException e) {
+      log.debug("디렉토리 용량 계산 중 오류 발생: {}", directoryPath, e);
+      return FileManagerDto.StorageSpaceRes.builder()
+          .directoryPath(directoryPath)
+          .fileCount(0)
+          .directoryCount(0)
+          .usedSize(0L)
+          .usedSizeFormatted("0 B")
+          .totalDiskSpace(0L)
+          .totalDiskSpaceFormatted("0 B")
+          .freeSpace(0L)
+          .freeSpaceFormatted("0 B")
+          .usableSpace(0L)
+          .usableSpaceFormatted("0 B")
+          .usagePercentage(0.0)
+          .build();
+    }
+
+    // 디스크 공간 정보 조회 (FileStore 사용)
+    long totalDiskSpace = 0;
+    long freeSpace = 0;
+    long usableSpace = 0;
+    double usagePercentage = 0.0;
+
+    try {
+      java.nio.file.FileStore fileStore = Files.getFileStore(directory);
+      totalDiskSpace = fileStore.getTotalSpace(); // 전체 디스크 용량
+      freeSpace = fileStore.getUnallocatedSpace(); // 남은 저장공간 (할당되지 않은 공간)
+      usableSpace = fileStore.getUsableSpace(); // 사용 가능한 공간 (실제 사용 가능)
+
+      // 디스크 사용률 계산
+      if (totalDiskSpace > 0) {
+        long usedDiskSpace = totalDiskSpace - freeSpace;
+        usagePercentage = (usedDiskSpace * 100.0) / totalDiskSpace;
+      }
+    } catch (IOException e) {
+      log.debug("디스크 공간 정보 조회 중 오류 발생: {}", directoryPath, e);
+      // 디스크 정보 조회 실패 시에도 디렉토리 용량은 반환
+    }
+
+    return FileManagerDto.StorageSpaceRes.builder()
+        .directoryPath(directoryPath)
+        .fileCount(fileCount[0])
+        .directoryCount(directoryCount[0])
+        .usedSize(usedSize[0])
+        .usedSizeFormatted(formatFileSize(usedSize[0]))
+        .totalDiskSpace(totalDiskSpace)
+        .totalDiskSpaceFormatted(formatFileSize(totalDiskSpace))
+        .freeSpace(freeSpace)
+        .freeSpaceFormatted(formatFileSize(freeSpace))
+        .usableSpace(usableSpace)
+        .usableSpaceFormatted(formatFileSize(usableSpace))
+        .usagePercentage(Math.round(usagePercentage * 100.0) / 100.0)
+        .build();
+  }
 }