SEBSP-210 tested SESSION_SCREENSHOT_DATA_CACHE and recorder

Author: anhefti

src/main/java/ch/ethz/seb/sps/server/datalayer/dao/ScreenshotDataDAO.java

@@ -30,18 +30,11 @@ public interface ScreenshotDataDAO extends EntityDAO<ScreenshotData, ScreenshotD
 
     Result<Collection<ScreenshotDataRecord>> allOfSession(String sessionUUID);
 
-    //Result<ScreenshotDataRecord> getAt(String sessionUUID, Long at);
-
-    //Result<Long> getIdAt(String sessionUUID, Long at);
-
-    //Result<Long> getLatestImageId(String sessionUUID);
-
     Result<Collection<Long>> getScreenshotTimestamps(String sessionUUID, Long timestamp, PageSortOrder sortOrder);
 
     Result<ScreenshotDataRecord> getLatest(String sessionUUID);
 
     Result<Map<String, ScreenshotDataRecord>> allOfMappedToSession(List<Long> pks);
-    //Result<Map<String, ScreenshotDataRecord>> allLatestIn(List<String> sessionUUIDs);
 
     Result<Long> save(
             String sessionId,

src/main/java/ch/ethz/seb/sps/server/datalayer/dao/SessionDAO.java

@@ -12,6 +12,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import ch.ethz.seb.sps.domain.model.EntityKey;
 import ch.ethz.seb.sps.domain.model.FilterMap;

src/main/java/ch/ethz/seb/sps/server/datalayer/dao/impl/ScreenshotDataDAOBatis.java

@@ -19,7 +19,6 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -120,119 +119,6 @@ public Result<Collection<ScreenshotDataRecord>> allOfSession(final String sessio
                 .execute());
     }
 
-//    @Override
-//    @Transactional(readOnly = true)
-//    public Result<ScreenshotDataRecord> getAt(final String sessionUUID, final Long at) {
-//        
-//        System.out.print("******************** getAt called for session: " + sessionUUID + " with at: " + at);
-//        
-//        // TODO: this seems to produce performance issues when table is huge. Try to optimize query by reducing the time frame here
-//        return Result.tryCatch(() -> {
-//            ScreenshotDataRecord record = SelectDSL
-//                    .selectWithMapper(this.screenshotDataRecordMapper::selectOne,
-//                            id,
-//                            sessionUuid,
-//                            timestamp,
-//                            imageFormat,
-//                            metaData,
-//                            timestamp)
-//                    .from(screenshotDataRecord)
-//                    .where(ScreenshotDataRecordDynamicSqlSupport.sessionUuid, SqlBuilder.isEqualTo(sessionUUID))
-//                    .and(ScreenshotDataRecordDynamicSqlSupport.timestamp, SqlBuilder.isLessThanOrEqualTo(at))
-//                    .orderBy(timestamp.descending())
-//                    .limit(1)
-//                    .build()
-//                    .execute();
-//
-//            if (record != null) {
-//                return record;
-//            }
-//
-//            // there is no screenshot at the time of given timestamp. Try to get first image for the session
-//            record = SelectDSL
-//                    .selectWithMapper(this.screenshotDataRecordMapper::selectOne,
-//                            id,
-//                            sessionUuid,
-//                            timestamp,
-//                            imageFormat,
-//                            metaData,
-//                            timestamp)
-//                    .from(screenshotDataRecord)
-//                    .where(ScreenshotDataRecordDynamicSqlSupport.sessionUuid, SqlBuilder.isEqualTo(sessionUUID))
-//                    .orderBy(timestamp)
-//                    .limit(1)
-//                    .build()
-//                    .execute();
-//
-//            // still no screenshot... seems that there are none at this time
-//            if (record == null) {
-//                throw new NoResourceFoundException(EntityType.SCREENSHOT_DATA, sessionUUID);
-//            }
-//
-//            return record;
-//        });
-//    }
-
-//    @Override
-//    @Transactional(readOnly = true)
-//    public Result<Long> getIdAt(final String sessionUUID, final Long at) {
-//        return Result.tryCatch(() -> {
-//
-//            System.out.println("******************** getIdAt called for session: " + sessionUUID + " with at: " + at);
-//
-//            List<Long> result = SelectDSL
-//                    .selectWithMapper(this.screenshotDataRecordMapper::selectIds, id, timestamp)
-//                    .from(screenshotDataRecord)
-//                    .where(ScreenshotDataRecordDynamicSqlSupport.sessionUuid, SqlBuilder.isEqualTo(sessionUUID))
-//                    .and(ScreenshotDataRecordDynamicSqlSupport.timestamp, SqlBuilder.isLessThanOrEqualTo(at))
-//                    .orderBy(timestamp.descending())
-//                    .limit(1)
-//                    .build()
-//                    .execute();
-//
-//            if (result != null && !result.isEmpty()) {
-//                return result.get(0);
-//            }
-//
-//            // there is no screenshot at the time of given timestamp. Try to get first image for the session
-//            result = SelectDSL
-//                    .selectWithMapper(this.screenshotDataRecordMapper::selectIds, id, timestamp)
-//                    .from(screenshotDataRecord)
-//                    .where(ScreenshotDataRecordDynamicSqlSupport.sessionUuid, SqlBuilder.isEqualTo(sessionUUID))
-//                    .orderBy(timestamp)
-//                    .limit(1)
-//                    .build()
-//                    .execute();
-//
-//            // still no screenshot... seems that there are none at this time
-//            if (result == null || result.isEmpty()) {
-//                throw new NoResourceFoundException(EntityType.SCREENSHOT_DATA, sessionUUID);
-//            }
-//
-//            return result.get(0);
-//        });
-//    }
-
-//    @Override
-//    @Transactional(readOnly = true)
-//    public Result<Long> getLatestImageId(final String sessionUUID) {
-//        return Result.tryCatch(() -> {
-//
-//            System.out.println("******************** getLatestImageId called for session: " + sessionUUID );
-//
-//            final List<Long> execute = SelectDSL
-//                    .selectDistinctWithMapper(this.screenshotDataRecordMapper::selectIds, id, timestamp)
-//                    .from(screenshotDataRecord)
-//                    .where(ScreenshotDataRecordDynamicSqlSupport.sessionUuid, SqlBuilder.isEqualTo(sessionUUID))
-//                    .orderBy(timestamp.descending())
-//                    .limit(1)
-//                    .build()
-//                    .execute();
-//
-//            return execute.get(0);
-//        });
-//    }
-
     @Override
     @Transactional(readOnly = true)
     public Result<ScreenshotDataRecord> getLatest(final String sessionUUID) {
@@ -271,43 +157,6 @@ public Result<Map<String, ScreenshotDataRecord>> allOfMappedToSession(final List
         });
     }
 
-//    @Override
-//    @Transactional(readOnly = true)
-//    public Result<Map<String, ScreenshotDataRecord>> allLatestIn(final List<String> sessionUUIDs) {
-//        return Result.tryCatch(() -> {
-//            if (sessionUUIDs == null || sessionUUIDs.isEmpty()) {
-//                return Collections.emptyMap();
-//            }
-//
-//            // NOTE: This was not working as expected since limit does not work with group (groupBy)
-////            return SelectDSL
-////                    .selectWithMapper(this.screenshotDataRecordMapper::selectMany,
-////                            id,
-////                            sessionUuid,
-////                            timestamp,
-////                            imageFormat,
-////                            metaData)
-////                    .from(screenshotDataRecord)
-////                    .where(ScreenshotDataRecordDynamicSqlSupport.sessionUuid, SqlBuilder.isIn(sessionUUIDs))
-////                    .groupBy(ScreenshotDataRecordDynamicSqlSupport.sessionUuid)
-////                    .orderBy(timestamp.descending())
-////                    .limit(1)
-////                    .build()
-////                    .execute()
-////                    .stream()
-////                    .collect(Collectors.toMap(r -> r.getSessionUuid(), Function.identity()));
-//
-//            // NOTE: For now we use a less efficient version that uses getLatest(final String sessionUUID) for
-//            //       all requested sessions but in the future we should solve this problem on DB layer
-//            return sessionUUIDs.stream()
-//                    .map(this::getLatestScreenshotDataRec)
-//                    .filter(Objects::nonNull)
-//                    .collect(Collectors.toMap(
-//                            ScreenshotDataRecord::getSessionUuid, 
-//                            Function.identity()));
-//        });
-//    }
-
     @Override
     @Transactional(readOnly = true)
     public Result<Collection<ScreenshotData>> allMatching(

src/main/java/ch/ethz/seb/sps/server/servicelayer/impl/ProctoringCacheService.java

@@ -162,9 +162,13 @@ public SessionScreenshotCacheData getSessionScreenshotData(final String sessionU
         if (result.hasError()) {
             log.warn("Failed to get all screenshot data for session: {}", sessionUUID);
             return null;
+        } else {
+            Collection<ScreenshotDataRecord> screenshotDataRecords = result.get();
+            if (log.isDebugEnabled()) {
+                log.debug("Got SessionScreenshotCacheData for session: {} with {} entries", sessionUUID, screenshotDataRecords.size());
+            }
+            return new SessionScreenshotCacheData(sessionUUID, screenshotDataRecords);
         }
-        
-        return new SessionScreenshotCacheData(sessionUUID, result.get());
     }
 
     @CacheEvict(

src/main/java/ch/ethz/seb/sps/server/servicelayer/impl/ProctoringServiceImpl.java

@@ -8,6 +8,7 @@
 
 package ch.ethz.seb.sps.server.servicelayer.impl;
 
+import javax.cache.Cache;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.sql.Date;
@@ -21,8 +22,12 @@
 import ch.ethz.seb.sps.server.datalayer.dao.*;
 import ch.ethz.seb.sps.server.servicelayer.LiveProctoringCacheService;
 import org.apache.tomcat.util.http.fileupload.IOUtils;
+import org.ehcache.core.Ehcache;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.boot.autoconfigure.cache.CacheProperties;
+import org.springframework.cache.CacheManager;
+import org.springframework.cache.jcache.JCacheCache;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.stereotype.Component;
 
@@ -59,6 +64,7 @@ public class ProctoringServiceImpl implements ProctoringService {
     private final UserService userService;
     private final ServiceInfo serviceInfo;
     private final JSONMapper jsonMapper;
+    private final CacheManager cacheManager;
     private final boolean isDistributedSetup;
     private final long distributedUpdateInterval;
 
@@ -68,11 +74,12 @@ public ProctoringServiceImpl(
             final SessionDAO sessionDAO,
             final ScreenshotDAO screenshotDAO,
             final ScreenshotDataDAO screenshotDataDAO,
-            final ProctoringCacheService proctoringCacheService, 
+            final ProctoringCacheService proctoringCacheService,
             final LiveProctoringCacheService liveProctoringCacheService,
             final UserService userService,
             final ServiceInfo serviceInfo,
-            final JSONMapper jsonMapper) {
+            final JSONMapper jsonMapper, 
+            final CacheManager cacheManager) {
 
         this.examDAO = examDAO;
         this.groupDAO = groupDAO;
@@ -86,7 +93,8 @@ public ProctoringServiceImpl(
         this.jsonMapper = jsonMapper;
         this.distributedUpdateInterval = serviceInfo.getDistributedUpdateInterval();
         this.isDistributedSetup = serviceInfo.isDistributed();
-     }
+        this.cacheManager = cacheManager;
+    }
 
     @Override
     public void checkMonitoringAccess(final String groupUUID) {
@@ -109,32 +117,18 @@ public void checkMonitoringSessionAccess(final String sessionUUID) {
     }
 
     @Override
-    public Result<ScreenshotViewData> getRecordedImageDataAt(final String sessionUUID, final Long timestamp) {
+    public synchronized Result<ScreenshotViewData> getRecordedImageDataAt(final String sessionUUID, final Long timestamp) {
         return Result.tryCatch(() -> {
-            if (timestamp != null) {
-
-                return createScreenshotViewData(
-                        sessionUUID,
-                        this.proctoringCacheService.getSessionScreenshotData(sessionUUID).getAt(timestamp));
-            } else {
-                Long latestSSDataId = this.liveProctoringCacheService.getLatestSSDataId(sessionUUID, true);
-                if (latestSSDataId != null && latestSSDataId != -1L) {
-                    return screenshotDataDAO
-                            .recordByPK(latestSSDataId)
-                            .map(data -> createScreenshotViewData(sessionUUID, data))
-                            .getOrThrow();
-                } else {
-                    if (log.isDebugEnabled()) {
-                        log.debug("No latest screenshot available yet for session: {}", sessionUUID);
-                    }
-                    throw new NoResourceFoundException(EntityType.SCREENSHOT_DATA, "No latest screenshot available yet");
-                }
-            }
+            final SessionScreenshotCacheData sessionScreenshotData = this.proctoringCacheService
+                    .getSessionScreenshotData(sessionUUID);
+            return createScreenshotViewData(
+                    sessionUUID,
+                    sessionScreenshotData.getAt(timestamp));
         });
     }
 
     @Override
-    public Result<ScreenshotsInGroupData> getSessionsByGroup(
+    public synchronized Result<ScreenshotsInGroupData> getSessionsByGroup(
             final String groupUUID,
             final Integer pageNumber,
             final Integer pageSize,
@@ -429,11 +423,6 @@ private void streamLatestScreenshot(final String sessionUUID, final OutputStream
             screenshotIn =  this.screenshotDAO
                     .getImage(this.liveProctoringCacheService.getLatestSSDataId(sessionUUID, true), sessionUUID)
                     .getOrThrow();
-//
-//            screenshotIn = this.screenshotDataDAO
-//                    .getLatestImageId(sessionUUID)
-//                    .flatMap(pk -> this.screenshotDAO.getImage(pk, sessionUUID))
-//                    .getOrThrow();
 
             IOUtils.copy(screenshotIn, out);
 
@@ -469,11 +458,6 @@ private void streamScreenshotAt(
                     .getImage(at.getId(), sessionUUID)
                     .getOrThrow();
 
-//            screenshotIn = this.screenshotDataDAO
-//                    .getIdAt(sessionUUID, timestamp)
-//                    .flatMap(pk -> this.screenshotDAO.getImage(pk, sessionUUID))
-//                    .getOrThrow();
-
             IOUtils.copy(screenshotIn, out);
         } catch (final Exception e) {
             if (e instanceof RuntimeException) {
@@ -627,7 +611,6 @@ private void updateSessionCache(String groupUUID) {
                 this.clearGroupCache(groupUUID, true);
             } else {
 
-                // TODO use CacheManager to get all actual cached sessions to update
                 Map<String, Long> updateTimes = this.proctoringCacheService
                         .getLiveSessionTokens(activeGroup.uuid)
                         .stream()

src/main/java/ch/ethz/seb/sps/server/servicelayer/impl/SessionScreenshotCacheData.java

@@ -25,7 +25,7 @@ public SessionScreenshotCacheData(
             final Collection<ScreenshotDataRecord> data) {
 
         this.sessionUUID = sessionUUID;
-        this.data = data.toArray(new ScreenshotDataRecord[data.size()]);
+        this.data = data.toArray(new ScreenshotDataRecord[0]);
         Arrays.sort(
                 this.data, 
                 Comparator.comparing(ScreenshotDataRecord::getTimestamp));
@@ -36,6 +36,10 @@ public SessionScreenshotCacheData(
     }
 
     public ScreenshotDataRecord getAt(Long timestamp) {
+        if (timestamp == null) {
+            return data[0];
+        }
+        
         final int i = Arrays.binarySearch(timestamps, timestamp);
         if (i >= 0) {
             return data[i];