SEBSP-217 fixed various little issues with live caching

anhefti · anhefti · commit 1d166716f045 · 2025-12-09T11:27:00.000+01:00
diff --git a/pom.xml b/pom.xml
@@ -16,7 +16,7 @@
     <packaging>jar</packaging>
 
     <properties>
-        <seb-sps-version>1.2.3_SNAPSHOT</seb-sps-version>
+        <seb-sps-version>1.2.2</seb-sps-version>
         <build-version>${seb-sps-version}</build-version>
         <revision>${seb-sps-version}</revision>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
diff --git a/src/main/java/ch/ethz/seb/sps/server/datalayer/dao/ScreenshotDataLiveCacheDAO.java b/src/main/java/ch/ethz/seb/sps/server/datalayer/dao/ScreenshotDataLiveCacheDAO.java
@@ -18,8 +18,6 @@ public interface ScreenshotDataLiveCacheDAO {
     
     Result<ScreenshotDataLiveCacheRecord> createCacheEntry(String sessionUUID);
 
-    Result<ScreenshotDataLiveCacheRecord> createCacheEntry(String sessionUUID, Long value);
-
     Result<String> deleteCacheEntry(String sessionUUID);
     
     Result<List<String>> deleteAll(List<String> sessionUUIDs);
diff --git a/src/main/java/ch/ethz/seb/sps/server/datalayer/dao/impl/ScreenshotDataLiveCacheDAOBatis.java b/src/main/java/ch/ethz/seb/sps/server/datalayer/dao/impl/ScreenshotDataLiveCacheDAOBatis.java
@@ -13,6 +13,7 @@
 
 import ch.ethz.seb.sps.server.datalayer.batis.mapper.ScreenshotDataLiveCacheRecordDynamicSqlSupport;
 import ch.ethz.seb.sps.server.datalayer.batis.mapper.ScreenshotDataLiveCacheRecordMapper;
+import ch.ethz.seb.sps.server.datalayer.batis.mapper.ScreenshotDataRecordMapper;
 import ch.ethz.seb.sps.server.datalayer.batis.model.ScreenshotDataLiveCacheRecord;
 import ch.ethz.seb.sps.server.datalayer.dao.ScreenshotDataLiveCacheDAO;
 import ch.ethz.seb.sps.utils.Result;
@@ -22,32 +23,32 @@
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import static ch.ethz.seb.sps.server.datalayer.batis.mapper.ScreenshotDataRecordDynamicSqlSupport.sessionUuid;
+
 @Service
 public class ScreenshotDataLiveCacheDAOBatis implements ScreenshotDataLiveCacheDAO {
 
     private static final Logger log = LoggerFactory.getLogger(ScreenshotDataLiveCacheDAOBatis.class);
 
     private final ScreenshotDataLiveCacheRecordMapper screenshotDataLiveCacheRecordMapper;
+    private final ScreenshotDataRecordMapper screenshotDataRecordMapper;
+
+    public ScreenshotDataLiveCacheDAOBatis(
+            final ScreenshotDataLiveCacheRecordMapper screenshotDataLiveCacheRecordMapper,
+            final ScreenshotDataRecordMapper screenshotDataRecordMapper) {
 
-    public ScreenshotDataLiveCacheDAOBatis(ScreenshotDataLiveCacheRecordMapper screenshotDataLiveCacheRecordMapper) {
         this.screenshotDataLiveCacheRecordMapper = screenshotDataLiveCacheRecordMapper;
+        this.screenshotDataRecordMapper = screenshotDataRecordMapper;
     }
 
     @Override
     @Transactional
     public Result<ScreenshotDataLiveCacheRecord> createCacheEntry(String sessionUUID) {
         return Result
-            .tryCatch(() ->  screenshotDataLiveCacheRecordMapper.selectByPrimaryKey(createSlot(sessionUUID, null)))
+            .tryCatch(() ->  screenshotDataLiveCacheRecordMapper.selectByPrimaryKey(createSlot(sessionUUID)))
             .onError(TransactionHandler::rollback);
     }
 
-    @Override
-    @Transactional
-    public Result<ScreenshotDataLiveCacheRecord> createCacheEntry(String sessionUUID, Long value) {
-        return Result
-            .tryCatch(() ->  screenshotDataLiveCacheRecordMapper.selectByPrimaryKey(createSlot(sessionUUID, value)))
-            .onError(TransactionHandler::rollback);
-    }
 
     @Override
     @Transactional
@@ -96,13 +97,73 @@ public Result<Collection<ScreenshotDataLiveCacheRecord>> getAll() {
         });
     }
 
-    private synchronized Long createSlot(String sessionUUID, Long value) {
-        final ScreenshotDataLiveCacheRecord rec = new ScreenshotDataLiveCacheRecord(
-                null,
-                sessionUUID,
-                value != null && value >= 0 ? value : null );
+    private synchronized Long createSlot(String sessionUUID) {
+        List<ScreenshotDataLiveCacheRecord> existing = screenshotDataLiveCacheRecordMapper
+                .selectByExample()
+                .where(
+                        ScreenshotDataLiveCacheRecordDynamicSqlSupport.sessionUuid,
+                        SqlBuilder.isEqualTo(sessionUUID))
+                .build()
+                .execute();
+
+        if (existing != null && !existing.isEmpty()) {
+            // we have already an entry, we can use that
+            if (existing.size() > 1) {
+                log.warn("Expected one cache entry for session: {} but found: {}", sessionUUID, existing.size());
+            }
+
+            ScreenshotDataLiveCacheRecord rec = existing.get(0);
+            if (rec.getIdLatestSsd() != null) {
+                return rec.getIdLatestSsd();
+            } else {
+                // get value, update with value and return PK
+                Long lastScreenshotEntryId = getLastScreenshotEntryId(sessionUUID);
+                if (lastScreenshotEntryId != null) {
+                    screenshotDataLiveCacheRecordMapper.updateByPrimaryKey(new ScreenshotDataLiveCacheRecord(
+                            rec.getId(),
+                            rec.getSessionUuid(),
+                            lastScreenshotEntryId
+                    ));
+                    return rec.getId();
+                } else {
+                    return null;
+                }
+            }
+        } else {
+            // get value create slot with value and return PK
+            Long lastScreenshotEntryId = getLastScreenshotEntryId(sessionUUID);
+            if (lastScreenshotEntryId != null) {
+                ScreenshotDataLiveCacheRecord rec = new ScreenshotDataLiveCacheRecord(
+                        null,
+                        sessionUUID,
+                        lastScreenshotEntryId
+                );
+                screenshotDataLiveCacheRecordMapper.insert(rec);
+                return rec.getId();
+            } else {
+                return null;
+            }
+        }
+    }
+
+    private Long getLastScreenshotEntryId(String sessionUUID) {
+        try {
+
+            List<Long> all = screenshotDataRecordMapper
+                    .selectIdsByExample()
+                    .where(sessionUuid, SqlBuilder.isEqualTo(sessionUUID))
+                    .build()
+                    .execute();
+
+            if (all != null) {
+                return all.get(all.size() - 1);
+            }
 
-        screenshotDataLiveCacheRecordMapper.insert(rec);
-        return rec.getId();
+            log.warn("No screenshot entry found for session: {}", sessionUUID);
+            return null;
+        } catch (Exception e) {
+            log.error("Failed to get last screenshot entry for session: {} error: {}", sessionUUID, e.getMessage());
+            return null;
+        }
     }
 }
diff --git a/src/main/java/ch/ethz/seb/sps/server/servicelayer/LiveProctoringCacheService.java b/src/main/java/ch/ethz/seb/sps/server/servicelayer/LiveProctoringCacheService.java
@@ -10,11 +10,8 @@
 
 import java.util.Collection;
 
-import ch.ethz.seb.sps.domain.model.service.ScreenshotViewData;
 import ch.ethz.seb.sps.server.ServiceInitEvent;
-import ch.ethz.seb.sps.server.datalayer.batis.model.ScreenshotDataRecord;
 import ch.ethz.seb.sps.server.servicelayer.impl.ScreenshotQueueData;
-import ch.ethz.seb.sps.utils.Result;
 import org.springframework.context.event.EventListener;
 
 public interface LiveProctoringCacheService {
@@ -27,7 +24,7 @@ public interface LiveProctoringCacheService {
      * @param sessionUUID The live session UUID
      * @return PK id of the last screenshot_data row if available or -1 if there is no screenshot yet or null
      *         if there is no slot for the given sessionUUID*/
-    Long getLatestSSDataId(String sessionUUID, boolean createSlot);
+    Long getLatestSSDataId(String sessionUUID);
 
     /** Called by the batch store services to update latest cache entries on storage
      * @param batch The batch with the latest screenshot_data ids */
diff --git a/src/main/java/ch/ethz/seb/sps/server/servicelayer/impl/LiveProctoringCacheServiceImpl.java b/src/main/java/ch/ethz/seb/sps/server/servicelayer/impl/LiveProctoringCacheServiceImpl.java
@@ -115,8 +115,8 @@ public void init() {
     }
 
     @Override
-    public Long getLatestSSDataId(final String sessionUUID, final boolean createSlot) {
-        if (!cache.containsKey(sessionUUID) && createSlot) {
+    public Long getLatestSSDataId(final String sessionUUID) {
+        if (!cache.containsKey(sessionUUID)) {
 
             if (!this.sessionDAO.isActive(sessionUUID)) {
                 return null;
@@ -129,9 +129,8 @@ public Long getLatestSSDataId(final String sessionUUID, final boolean createSlot
             synchronized (this.cache) {
                 screenshotDataLiveCacheDAO
                         .createCacheEntry(sessionUUID)
-                        .onError(error -> log.error("Failed to create slot for session: {}", sessionUUID));
-
-                cache.put(sessionUUID, -1L);
+                        .onError(error -> log.error("Failed to create slot for session: {}", sessionUUID))
+                        .onSuccess(rec -> cache.put(sessionUUID, rec.getIdLatestSsd()));
             }
         }
         
diff --git a/src/main/java/ch/ethz/seb/sps/server/servicelayer/impl/ProctoringServiceImpl.java b/src/main/java/ch/ethz/seb/sps/server/servicelayer/impl/ProctoringServiceImpl.java
@@ -133,7 +133,7 @@ public synchronized Result<ScreenshotViewData> getRecordedImageDataAt(final Stri
                 // this means last timestamp and only should be called on live recording views
                 if (sessionActive) {
                     // get latest screenshot data form DB and check if we need an update on session cache
-                    Long pk = liveProctoringCacheService.getLatestSSDataId(sessionUUID, false);
+                    Long pk = liveProctoringCacheService.getLatestSSDataId(sessionUUID);
                     if (pk == null || pk < 0) {
                         if (log.isDebugEnabled()) {
                             log.warn("Failed to get live screenshot id for session: {}", sessionUUID );
@@ -151,11 +151,7 @@ public synchronized Result<ScreenshotViewData> getRecordedImageDataAt(final Stri
                     .getSessionScreenshotData(sessionUUID);
 
             if (sessionActive) {
-                // check first if cache is up to date if timestamp is after last timestamp in cache, reload cache first
-                if (sessionScreenshotData.timestamps[sessionScreenshotData.timestamps.length - 1] < timestamp) {
-                    proctoringCacheService.evictSessionScreenshotData(sessionUUID);
-                    sessionScreenshotData = this.proctoringCacheService.getSessionScreenshotData(sessionUUID);
-                }
+                sessionScreenshotData = getActualSessionScreenshotCacheData(timestamp, sessionUUID, sessionScreenshotData);
             }
 
             return createScreenshotViewData(sessionUUID, sessionScreenshotData.getAt(timestamp));
@@ -209,7 +205,7 @@ public synchronized Result<ScreenshotsInGroupData> getSessionsByGroup(
                     .allOfMappedToSession(
                             sessionIdsInOrder
                                     .stream()
-                                    .map(uuid -> liveProctoringCacheService.getLatestSSDataId(uuid, true))
+                                    .map(liveProctoringCacheService::getLatestSSDataId)
                                     .toList())
                     .getOrThrow();
 
@@ -454,9 +450,14 @@ public DistinctMetadataWindowForExam getDistinctMetadataWindowForExam(final Stri
     private void streamLatestScreenshot(final String sessionUUID, final OutputStream out) {
         InputStream screenshotIn = null;
         try {
-            
+
+            Long latestSSDataId = this.liveProctoringCacheService.getLatestSSDataId(sessionUUID);
+            if (latestSSDataId == null) {
+                return;
+            }
+
             screenshotIn =  this.screenshotDAO
-                    .getImage(this.liveProctoringCacheService.getLatestSSDataId(sessionUUID, true), sessionUUID)
+                    .getImage(latestSSDataId, sessionUUID)
                     .getOrThrow();
 
             IOUtils.copy(screenshotIn, out);
@@ -477,7 +478,7 @@ private void streamScreenshotAt(
             final Long timestamp,
             final OutputStream out) {
         
-        if (timestamp == null) {
+        if (timestamp == null || Utils.getMillisecondsNow() - timestamp < 5 * Constants.SECOND_IN_MILLIS) {
             streamLatestScreenshot(sessionUUID, out);
             return;
         }
@@ -487,14 +488,6 @@ private void streamScreenshotAt(
 
             SessionScreenshotCacheData sessionScreenshotData = this.proctoringCacheService
                     .getSessionScreenshotData(sessionUUID);
-
-            if (timestamp - sessionScreenshotData.timestamps[sessionScreenshotData.timestamps.length - 1] > 5 * Constants.SECOND_IN_MILLIS ) {
-                // refresh the session cache
-                this.proctoringCacheService.evictSessionScreenshotData(sessionUUID);
-                this.proctoringCacheService
-                        .getSessionScreenshotData(sessionUUID);
-            }
-
             final ScreenshotDataRecord at = sessionScreenshotData.getAt(timestamp);
 
             screenshotIn = this.screenshotDAO
@@ -673,4 +666,22 @@ private void updateSessionCache(String groupUUID) {
         }
     }
 
+    // this can be used if we still have a live session, but it might be outdated or abandoned by SEB...
+    // check first if cache is up to date with the last image from live cache and refresh the cache only if needed
+    private SessionScreenshotCacheData getActualSessionScreenshotCacheData(
+            final Long timestamp,
+            final String sessionUUID,
+            final SessionScreenshotCacheData data) {
+
+        Long pk = liveProctoringCacheService.getLatestSSDataId(sessionUUID);
+        ScreenshotDataRecord lastCacheEntry = data.data[data.data.length - 1];
+        if (pk != null) {
+            if (lastCacheEntry.getTimestamp() < timestamp && !Objects.equals(pk, lastCacheEntry.getId())) {
+                proctoringCacheService.evictSessionScreenshotData(sessionUUID);
+                return this.proctoringCacheService.getSessionScreenshotData(sessionUUID);
+            }
+        }
+        return data;
+    }
+
 }
diff --git a/src/test/java/ch/ethz/seb/sps/server/servicelayer/proctoringservice/ProctoringServiceGroupTest.java b/src/test/java/ch/ethz/seb/sps/server/servicelayer/proctoringservice/ProctoringServiceGroupTest.java
@@ -161,7 +161,7 @@ private void mockDependenciesForEmptyResult(){
     }
 
     private void mockDependenciesForRealisticResult() throws JsonProcessingException {
-        when( this.liveProctoringCacheService.getLatestSSDataId(any(), anyBoolean()))
+        when( this.liveProctoringCacheService.getLatestSSDataId(any()))
                 .thenReturn(-1L);
         
         when(this.proctoringCacheService.getActiveGroup(any()))

Original file line number	Diff line number	Diff line change
`@@ -115,8 +115,8 @@ public void init() {`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`@Override`
`118`		`- public Long getLatestSSDataId(final String sessionUUID, final boolean createSlot) {`
`119`		`- if (!cache.containsKey(sessionUUID) && createSlot) {`
	`118`	`+ public Long getLatestSSDataId(final String sessionUUID) {`
	`119`	`+ if (!cache.containsKey(sessionUUID)) {`
`120`	`120`
`121`	`121`	`if (!this.sessionDAO.isActive(sessionUUID)) {`
`122`	`122`	`return null;`
`@@ -129,9 +129,8 @@ public Long getLatestSSDataId(final String sessionUUID, final boolean createSlot`
`129`	`129`	`synchronized (this.cache) {`
`130`	`130`	`screenshotDataLiveCacheDAO`
`131`	`131`	`.createCacheEntry(sessionUUID)`
`132`		`- .onError(error -> log.error("Failed to create slot for session: {}", sessionUUID));`
`133`		`-`
`134`		`- cache.put(sessionUUID, -1L);`
	`132`	`+ .onError(error -> log.error("Failed to create slot for session: {}", sessionUUID))`
	`133`	`+ .onSuccess(rec -> cache.put(sessionUUID, rec.getIdLatestSsd()));`
`135`	`134`	`}`
`136`	`135`	`}`
`137`	`136`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ private void mockDependenciesForEmptyResult(){`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`private void mockDependenciesForRealisticResult() throws JsonProcessingException {`
`164`		`- when( this.liveProctoringCacheService.getLatestSSDataId(any(), anyBoolean()))`
	`164`	`+ when( this.liveProctoringCacheService.getLatestSSDataId(any()))`
`165`	`165`	`.thenReturn(-1L);`
`166`	`166`
`167`	`167`	`when(this.proctoringCacheService.getActiveGroup(any()))`