feat(stream): implement section saving

src/main/java/com/ddf/vodsystem/services/DirectoryService.java

@@ -59,6 +59,19 @@ public class DirectoryService {
         return file;
     }
 
+    public File getVodFile(String filename) {
+        String dir = outputDir + File.separator + "vods" + File.separator + filename;
+        File file = new File(dir);
+
+        try {
+            createDirectory(file.getParent());
+        } catch (IOException e) {
+            logger.error("Error creating vods directory: {}", e.getMessage());
+        }
+
+        return file;
+    }
+
     public File getUserThumbnailsFile(Long userId, String fileName) {
         if (userId == null || fileName == null || fileName.isEmpty()) {
             throw new IllegalArgumentException("User ID and file name cannot be null or empty");

src/main/java/com/ddf/vodsystem/services/StreamService.java

@@ -4,21 +4,42 @@ import com.ddf.vodsystem.entities.Stream;
 import com.ddf.vodsystem.entities.User;
 import com.ddf.vodsystem.exceptions.AlreadyStreaming;
 import com.ddf.vodsystem.exceptions.KeyNotFound;
+import com.ddf.vodsystem.exceptions.NotAuthenticated;
 import com.ddf.vodsystem.repositories.StreamRepository;
+import com.ddf.vodsystem.services.media.StreamActionsService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
+import java.io.File;
+import java.io.IOException;
+import java.time.Instant;
 import java.time.LocalDateTime;
+import java.time.ZoneOffset;
 import java.util.List;
 import java.util.Optional;
 
 @Service
 public class StreamService {
+    private static final Logger logger = LoggerFactory.getLogger(StreamService.class);
+    private static final int HEARTBEAT_TIMEOUT_SECONDS = 60;
+
     private final StreamRepository streamRepository;
     private final UserService userService;
+    private final StreamActionsService streamActionsService;
 
-    public StreamService(StreamRepository streamRepository, UserService userService) {
+    @Value("${storage.stream}")
+    private String streamDataPath;
+
+    public StreamService(StreamRepository streamRepository,
+                         UserService userService,
+                         StreamActionsService streamActionsService) {
         this.streamRepository = streamRepository;
         this.userService = userService;
+        this.streamActionsService = streamActionsService;
     }
 
     public Stream startStream(String streamKey) {
@@ -43,7 +64,6 @@ public class StreamService {
                 .orElseThrow(() -> new IllegalStateException(
                         "No active stream found for user " + user.getUsername()));
 
-
         stream.setEndDate(LocalDateTime.now());
         streamRepository.saveAndFlush(stream);
     }
@@ -70,6 +90,33 @@ public class StreamService {
         return streamRepository.findByUser(user);
     }
 
+    public void saveSection(Instant startTime, Instant endTime) throws IOException, InterruptedException {
+        User user = userService.getLoggedInUser()
+                .orElseThrow(() -> new NotAuthenticated("User is not authenticated"));
+
+        String streamDirectory = streamDataPath + File.separator + user.getStreamKey();
+        streamActionsService.saveSection(streamDirectory, startTime, endTime)
+                .exceptionally(ex -> {
+                    logger.error("saveSection failed for user {}: {}", user.getUsername(), ex.getMessage(), ex);
+                    return null;
+                });
+    }
+
+    @Scheduled(fixedDelay = 30_000)
+    @Transactional
+    public void endStaleStreams() {
+        LocalDateTime cutoff = LocalDateTime.now().minusSeconds(HEARTBEAT_TIMEOUT_SECONDS);
+        List<Stream> stale = streamRepository.findByEndDateIsNullAndLastSeenBefore(cutoff);
+        if (stale.isEmpty()) return;
+
+        LocalDateTime now = LocalDateTime.now();
+        for (Stream stream : stale) {
+            stream.setEndDate(now);
+            logger.warn("Stream {} for user {} ended due to heartbeat timeout", stream.getId(), stream.getUser().getUsername());
+        }
+        streamRepository.saveAllAndFlush(stale);
+    }
+
     private User resolveUser(String streamKey) {
         return userService.getUserByStreamKey(streamKey)
                 .orElseThrow(() -> new KeyNotFound("Stream key not found: " + streamKey));

src/main/java/com/ddf/vodsystem/services/media/StreamActionsService.java

@@ -0,0 +1,90 @@
+package com.ddf.vodsystem.services.media;
+
+import com.ddf.vodsystem.services.DirectoryService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.stereotype.Service;
+
+import java.io.File;
+import java.io.IOException;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+
+@Service
+public class StreamActionsService {
+    private static final Logger logger = LoggerFactory.getLogger(StreamActionsService.class);
+
+    private final DirectoryService directoryService;
+
+    public StreamActionsService(DirectoryService directoryService) {
+        this.directoryService = directoryService;
+    }
+
+    @Async("ffmpegTaskExecutor")
+    public CompletableFuture<File> saveSection(
+            String streamDirectory,
+            Instant startTime,
+            Instant endTime
+    ) throws IOException, InterruptedException {
+        List<File> segments = getSegmentsInRange(streamDirectory, startTime, endTime);
+        if (segments.isEmpty()) {
+            throw new IllegalArgumentException("No segments found in range [" + startTime + ", " + endTime + "]");
+        }
+
+        long firstSegmentMs = parseTimestampMs(segments.get(0));
+        float trimOffset = Math.max(0f, (startTime.toEpochMilli() - firstSegmentMs) / 1000f);
+        float duration = (endTime.toEpochMilli() - startTime.toEpochMilli()) / 1000f;
+
+        String concatInput = segments.stream()
+                .map(File::getAbsolutePath)
+                .collect(Collectors.joining("|"));
+
+        File outputFile = directoryService.getVodFile(UUID.randomUUID() + ".mp4");
+
+        List<String> command = List.of(
+                "ffmpeg",
+                "-y",
+                "-i", "concat:" + concatInput,
+                "-ss", String.valueOf(trimOffset),
+                "-t", String.valueOf(duration),
+                "-c", "copy",
+                outputFile.getAbsolutePath()
+        );
+
+        logger.info("Saving section [{} - {}] from '{}' ({} segments) to '{}'",
+                startTime, endTime, streamDirectory, segments.size(), outputFile.getAbsolutePath());
+        CommandRunner.run(command, line -> logger.debug("{}", line));
+
+        return CompletableFuture.completedFuture(outputFile);
+    }
+
+    private List<File> getSegmentsInRange(String streamDirectory, Instant startTime, Instant endTime) {
+        File dir = new File(streamDirectory);
+        File[] tsFiles = dir.listFiles((d, name) -> name.endsWith(".ts"));
+        if (tsFiles == null) return List.of();
+
+        long startMs = startTime.toEpochMilli();
+        long endMs = endTime.toEpochMilli();
+
+        return Arrays.stream(tsFiles)
+                .filter(f -> {
+                    long segMs = parseTimestampMs(f);
+                    return segMs < endMs && segMs + 3_000 > startMs;
+                })
+                .sorted(Comparator.comparingLong(this::parseTimestampMs))
+                .collect(Collectors.toList());
+    }
+
+    private long parseTimestampMs(File file) {
+        String name = file.getName().replace(".ts", "");
+        long value = Long.parseLong(name);
+        // nginx hls_fragment_naming system uses seconds; convert to ms
+        return value < 1_000_000_000_000L ? value * 1000L : value;
+    }
+}