1 files changed, 52 insertions, 66 deletions

diff --git a/server/controllers/lazy-static.ts b/server/controllers/lazy-static.ts
index b082e41f6..dad30365c 100644
--- a/server/controllers/lazy-static.ts
+++ b/server/controllers/lazy-static.ts
@@ -1,14 +1,28 @@
 import cors from 'cors'
 import express from 'express'
-import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache'
-import { MActorImage } from '@server/types/models'
+import { CONFIG } from '@server/initializers/config'
 import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
-import { logger } from '../helpers/logger'
-import { ACTOR_IMAGES_SIZE, LAZY_STATIC_PATHS, STATIC_MAX_AGE } from '../initializers/constants'
-import { VideosCaptionCache, VideosPreviewCache } from '../lib/files-cache'
-import { actorImagePathUnsafeCache, downloadActorImageFromWorker } from '../lib/local-actor'
+import { FILES_CACHE, LAZY_STATIC_PATHS, STATIC_MAX_AGE } from '../initializers/constants'
+import {
+  AvatarPermanentFileCache,
+  VideoCaptionsSimpleFileCache,
+  VideoMiniaturePermanentFileCache,
+  VideoPreviewsSimpleFileCache,
+  VideoStoryboardsSimpleFileCache,
+  VideoTorrentsSimpleFileCache
+} from '../lib/files-cache'
 import { asyncMiddleware, handleStaticError } from '../middlewares'
-import { ActorImageModel } from '../models/actor/actor-image'
+
+// ---------------------------------------------------------------------------
+// Cache initializations
+// ---------------------------------------------------------------------------
+
+VideoPreviewsSimpleFileCache.Instance.init(CONFIG.CACHE.PREVIEWS.SIZE, FILES_CACHE.PREVIEWS.MAX_AGE)
+VideoCaptionsSimpleFileCache.Instance.init(CONFIG.CACHE.VIDEO_CAPTIONS.SIZE, FILES_CACHE.VIDEO_CAPTIONS.MAX_AGE)
+VideoTorrentsSimpleFileCache.Instance.init(CONFIG.CACHE.TORRENTS.SIZE, FILES_CACHE.TORRENTS.MAX_AGE)
+VideoStoryboardsSimpleFileCache.Instance.init(CONFIG.CACHE.STORYBOARDS.SIZE, FILES_CACHE.STORYBOARDS.MAX_AGE)
+
+// ---------------------------------------------------------------------------
 
 const lazyStaticRouter = express.Router()
 
@@ -27,12 +41,24 @@ lazyStaticRouter.use(
 )
 
 lazyStaticRouter.use(
+  LAZY_STATIC_PATHS.THUMBNAILS + ':filename',
+  asyncMiddleware(getThumbnail),
+  handleStaticError
+)
+
+lazyStaticRouter.use(
   LAZY_STATIC_PATHS.PREVIEWS + ':filename',
   asyncMiddleware(getPreview),
   handleStaticError
 )
 
 lazyStaticRouter.use(
+  LAZY_STATIC_PATHS.STORYBOARDS + ':filename',
+  asyncMiddleware(getStoryboard),
+  handleStaticError
+)
+
+lazyStaticRouter.use(
   LAZY_STATIC_PATHS.VIDEO_CAPTIONS + ':filename',
   asyncMiddleware(getVideoCaption),
   handleStaticError
@@ -53,88 +79,48 @@ export {
 }
 
 // ---------------------------------------------------------------------------
+const avatarPermanentFileCache = new AvatarPermanentFileCache()
 
-async function getActorImage (req: express.Request, res: express.Response, next: express.NextFunction) {
+function getActorImage (req: express.Request, res: express.Response, next: express.NextFunction) {
   const filename = req.params.filename
 
-  if (actorImagePathUnsafeCache.has(filename)) {
-    return res.sendFile(actorImagePathUnsafeCache.get(filename), { maxAge: STATIC_MAX_AGE.SERVER })
-  }
-
-  const image = await ActorImageModel.loadByName(filename)
-  if (!image) return res.status(HttpStatusCode.NOT_FOUND_404).end()
-
-  if (image.onDisk === false) {
-    if (!image.fileUrl) return res.status(HttpStatusCode.NOT_FOUND_404).end()
-
-    logger.info('Lazy serve remote actor image %s.', image.fileUrl)
-
-    try {
-      await downloadActorImageFromWorker({
-        filename: image.filename,
-        fileUrl: image.fileUrl,
-        size: getActorImageSize(image),
-        type: image.type
-      })
-    } catch (err) {
-      logger.warn('Cannot process remote actor image %s.', image.fileUrl, { err })
-      return res.status(HttpStatusCode.NOT_FOUND_404).end()
-    }
-
-    image.onDisk = true
-    image.save()
-      .catch(err => logger.error('Cannot save new actor image disk state.', { err }))
-  }
-
-  const path = image.getPath()
-
-  actorImagePathUnsafeCache.set(filename, path)
-
-  return res.sendFile(path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER }, (err: any) => {
-    if (!err) return
-
-    // It seems this actor image is not on the disk anymore
-    if (err.status === HttpStatusCode.NOT_FOUND_404 && !image.isOwned()) {
-      logger.error('Cannot lazy serve actor image %s.', filename, { err })
+  return avatarPermanentFileCache.lazyServe({ filename, res, next })
+}
 
-      actorImagePathUnsafeCache.delete(filename)
+// ---------------------------------------------------------------------------
+const videoMiniaturePermanentFileCache = new VideoMiniaturePermanentFileCache()
 
-      image.onDisk = false
-      image.save()
-       .catch(err => logger.error('Cannot save new actor image disk state.', { err }))
-    }
+function getThumbnail (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const filename = req.params.filename
 
-    return next(err)
-  })
+  return videoMiniaturePermanentFileCache.lazyServe({ filename, res, next })
 }
 
-function getActorImageSize (image: MActorImage): { width: number, height: number } {
-  if (image.width && image.height) {
-    return {
-      height: image.height,
-      width: image.width
-    }
-  }
+// ---------------------------------------------------------------------------
+
+async function getPreview (req: express.Request, res: express.Response) {
+  const result = await VideoPreviewsSimpleFileCache.Instance.getFilePath(req.params.filename)
+  if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
-  return ACTOR_IMAGES_SIZE[image.type][0]
+  return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 }
 
-async function getPreview (req: express.Request, res: express.Response) {
-  const result = await VideosPreviewCache.Instance.getFilePath(req.params.filename)
+async function getStoryboard (req: express.Request, res: express.Response) {
+  const result = await VideoStoryboardsSimpleFileCache.Instance.getFilePath(req.params.filename)
   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
   return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 }
 
 async function getVideoCaption (req: express.Request, res: express.Response) {
-  const result = await VideosCaptionCache.Instance.getFilePath(req.params.filename)
+  const result = await VideoCaptionsSimpleFileCache.Instance.getFilePath(req.params.filename)
   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
   return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 }
 
 async function getTorrent (req: express.Request, res: express.Response) {
-  const result = await VideosTorrentCache.Instance.getFilePath(req.params.filename)
+  const result = await VideoTorrentsSimpleFileCache.Instance.getFilePath(req.params.filename)
   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 
   // Torrents still use the old naming convention (video uuid + .torrent)