server/lib/actor-image.ts

   1 import 'multer'
   2 import { queue } from 'async'
   3 import * as LRUCache from 'lru-cache'
   4 import { extname, join } from 'path'
   5 import { v4 as uuidv4 } from 'uuid'
   6 import { ActorImageType } from '@shared/models'
   7 import { retryTransactionWrapper } from '../helpers/database-utils'
   8 import { processImage } from '../helpers/image-utils'
   9 import { downloadImage } from '../helpers/requests'
  10 import { CONFIG } from '../initializers/config'
  11 import { ACTOR_IMAGES_SIZE, LRU_CACHE, QUEUE_CONCURRENCY } from '../initializers/constants'
  12 import { sequelizeTypescript } from '../initializers/database'
  13 import { MAccountDefault, MChannelDefault } from '../types/models'
  14 import { deleteActorImageInstance, updateActorImageInstance } from './activitypub/actor'
  15 import { sendUpdateActor } from './activitypub/send'
  16
  17 async function updateLocalActorImageFile (
  18   accountOrChannel: MAccountDefault | MChannelDefault,
  19   imagePhysicalFile: Express.Multer.File,
  20   type: ActorImageType
  21 ) {
  22   const imageSize = type === ActorImageType.AVATAR
  23     ? ACTOR_IMAGES_SIZE.AVATARS
  24     : ACTOR_IMAGES_SIZE.BANNERS
  25
  26   const extension = extname(imagePhysicalFile.filename)
  27
  28   const imageName = uuidv4() + extension
  29   const destination = join(CONFIG.STORAGE.ACTOR_IMAGES, imageName)
  30   await processImage(imagePhysicalFile.path, destination, imageSize)
  31
  32   return retryTransactionWrapper(() => {
  33     return sequelizeTypescript.transaction(async t => {
  34       const actorImageInfo = {
  35         name: imageName,
  36         fileUrl: null,
  37         height: imageSize.height,
  38         width: imageSize.width,
  39         onDisk: true
  40       }
  41
  42       const updatedActor = await updateActorImageInstance(accountOrChannel.Actor, type, actorImageInfo, t)
  43       await updatedActor.save({ transaction: t })
  44
  45       await sendUpdateActor(accountOrChannel, t)
  46
  47       return type === ActorImageType.AVATAR
  48         ? updatedActor.Avatar
  49         : updatedActor.Banner
  50     })
  51   })
  52 }
  53
  54 async function deleteLocalActorImageFile (accountOrChannel: MAccountDefault | MChannelDefault, type: ActorImageType) {
  55   return retryTransactionWrapper(() => {
  56     return sequelizeTypescript.transaction(async t => {
  57       const updatedActor = await deleteActorImageInstance(accountOrChannel.Actor, type, t)
  58       await updatedActor.save({ transaction: t })
  59
  60       await sendUpdateActor(accountOrChannel, t)
  61
  62       return updatedActor.Avatar
  63     })
  64   })
  65 }
  66
  67 type DownloadImageQueueTask = { fileUrl: string, filename: string, type: ActorImageType }
  68
  69 const downloadImageQueue = queue<DownloadImageQueueTask, Error>((task, cb) => {
  70   const size = task.type === ActorImageType.AVATAR
  71     ? ACTOR_IMAGES_SIZE.AVATARS
  72     : ACTOR_IMAGES_SIZE.BANNERS
  73
  74   downloadImage(task.fileUrl, CONFIG.STORAGE.ACTOR_IMAGES, task.filename, size)
  75     .then(() => cb())
  76     .catch(err => cb(err))
  77 }, QUEUE_CONCURRENCY.ACTOR_PROCESS_IMAGE)
  78
  79 function pushActorImageProcessInQueue (task: DownloadImageQueueTask) {
  80   return new Promise<void>((res, rej) => {
  81     downloadImageQueue.push(task, err => {
  82       if (err) return rej(err)
  83
  84       return res()
  85     })
  86   })
  87 }
  88
  89 // Unsafe so could returns paths that does not exist anymore
  90 const actorImagePathUnsafeCache = new LRUCache<string, string>({ max: LRU_CACHE.ACTOR_IMAGE_STATIC.MAX_SIZE })
  91
  92 export {
  93   actorImagePathUnsafeCache,
  94   updateLocalActorImageFile,
  95   deleteLocalActorImageFile,
  96   pushActorImageProcessInQueue
  97 }