server/controllers/lazy-static.ts

   1 import cors from 'cors'
   2 import express from 'express'
   3 import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache'
   4 import { HttpStatusCode } from '../../shared/models/http/http-error-codes'
   5 import { logger } from '../helpers/logger'
   6 import { LAZY_STATIC_PATHS, STATIC_MAX_AGE } from '../initializers/constants'
   7 import { VideosCaptionCache, VideosPreviewCache } from '../lib/files-cache'
   8 import { actorImagePathUnsafeCache, pushActorImageProcessInQueue } from '../lib/local-actor'
   9 import { asyncMiddleware } from '../middlewares'
  10 import { ActorImageModel } from '../models/actor/actor-image'
  11
  12 const lazyStaticRouter = express.Router()
  13
  14 lazyStaticRouter.use(cors())
  15
  16 lazyStaticRouter.use(
  17   LAZY_STATIC_PATHS.AVATARS + ':filename',
  18   asyncMiddleware(getActorImage)
  19 )
  20
  21 lazyStaticRouter.use(
  22   LAZY_STATIC_PATHS.BANNERS + ':filename',
  23   asyncMiddleware(getActorImage)
  24 )
  25
  26 lazyStaticRouter.use(
  27   LAZY_STATIC_PATHS.PREVIEWS + ':filename',
  28   asyncMiddleware(getPreview)
  29 )
  30
  31 lazyStaticRouter.use(
  32   LAZY_STATIC_PATHS.VIDEO_CAPTIONS + ':filename',
  33   asyncMiddleware(getVideoCaption)
  34 )
  35
  36 lazyStaticRouter.use(
  37   LAZY_STATIC_PATHS.TORRENTS + ':filename',
  38   asyncMiddleware(getTorrent)
  39 )
  40
  41 // ---------------------------------------------------------------------------
  42
  43 export {
  44   lazyStaticRouter,
  45   getPreview,
  46   getVideoCaption
  47 }
  48
  49 // ---------------------------------------------------------------------------
  50
  51 async function getActorImage (req: express.Request, res: express.Response, next: express.NextFunction) {
  52   const filename = req.params.filename
  53
  54   if (actorImagePathUnsafeCache.has(filename)) {
  55     return res.sendFile(actorImagePathUnsafeCache.get(filename), { maxAge: STATIC_MAX_AGE.SERVER })
  56   }
  57
  58   const image = await ActorImageModel.loadByName(filename)
  59   if (!image) return res.status(HttpStatusCode.NOT_FOUND_404).end()
  60
  61   if (image.onDisk === false) {
  62     if (!image.fileUrl) return res.status(HttpStatusCode.NOT_FOUND_404).end()
  63
  64     logger.info('Lazy serve remote actor image %s.', image.fileUrl)
  65
  66     try {
  67       await pushActorImageProcessInQueue({
  68         filename: image.filename,
  69         fileUrl: image.fileUrl,
  70         size: {
  71           height: image.height,
  72           width: image.width
  73         },
  74         type: image.type
  75       })
  76     } catch (err) {
  77       logger.warn('Cannot process remote actor image %s.', image.fileUrl, { err })
  78       return res.status(HttpStatusCode.NOT_FOUND_404).end()
  79     }
  80
  81     image.onDisk = true
  82     image.save()
  83       .catch(err => logger.error('Cannot save new actor image disk state.', { err }))
  84   }
  85
  86   const path = image.getPath()
  87
  88   actorImagePathUnsafeCache.set(filename, path)
  89
  90   return res.sendFile(path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER }, (err: any) => {
  91     if (!err) return
  92
  93     // It seems this actor image is not on the disk anymore
  94     if (err.status === HttpStatusCode.NOT_FOUND_404 && !image.isOwned()) {
  95       logger.error('Cannot lazy serve actor image %s.', filename, { err })
  96
  97       actorImagePathUnsafeCache.del(filename)
  98
  99       image.onDisk = false
 100       image.save()
 101        .catch(err => logger.error('Cannot save new actor image disk state.', { err }))
 102     }
 103
 104     return next(err)
 105   })
 106 }
 107
 108 async function getPreview (req: express.Request, res: express.Response) {
 109   const result = await VideosPreviewCache.Instance.getFilePath(req.params.filename)
 110   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 111
 112   return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 113 }
 114
 115 async function getVideoCaption (req: express.Request, res: express.Response) {
 116   const result = await VideosCaptionCache.Instance.getFilePath(req.params.filename)
 117   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 118
 119   return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.LAZY_SERVER })
 120 }
 121
 122 async function getTorrent (req: express.Request, res: express.Response) {
 123   const result = await VideosTorrentCache.Instance.getFilePath(req.params.filename)
 124   if (!result) return res.status(HttpStatusCode.NOT_FOUND_404).end()
 125
 126   // Torrents still use the old naming convention (video uuid + .torrent)
 127   return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE.SERVER })
 128 }