server/lib/video-state.ts

   1 import { Transaction } from 'sequelize'
   2 import { logger } from '@server/helpers/logger'
   3 import { CONFIG } from '@server/initializers/config'
   4 import { sequelizeTypescript } from '@server/initializers/database'
   5 import { VideoModel } from '@server/models/video/video'
   6 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
   7 import { MVideoFullLight, MVideoUUID } from '@server/types/models'
   8 import { VideoState } from '@shared/models'
   9 import { federateVideoIfNeeded } from './activitypub/videos'
  10 import { Notifier } from './notifier'
  11 import { addMoveToObjectStorageJob } from './video'
  12
  13 function buildNextVideoState (currentState?: VideoState) {
  14   if (currentState === VideoState.PUBLISHED) {
  15     throw new Error('Video is already in its final state')
  16   }
  17
  18   if (
  19     currentState !== VideoState.TO_TRANSCODE &&
  20     currentState !== VideoState.TO_MOVE_TO_EXTERNAL_STORAGE &&
  21     CONFIG.TRANSCODING.ENABLED
  22   ) {
  23     return VideoState.TO_TRANSCODE
  24   }
  25
  26   if (
  27     currentState !== VideoState.TO_MOVE_TO_EXTERNAL_STORAGE &&
  28     CONFIG.OBJECT_STORAGE.ENABLED
  29   ) {
  30     return VideoState.TO_MOVE_TO_EXTERNAL_STORAGE
  31   }
  32
  33   return VideoState.PUBLISHED
  34 }
  35
  36 function moveToNextState (video: MVideoUUID, isNewVideo = true) {
  37   return sequelizeTypescript.transaction(async t => {
  38     // Maybe the video changed in database, refresh it
  39     const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
  40     // Video does not exist anymore
  41     if (!videoDatabase) return undefined
  42
  43     // Already in its final state
  44     if (videoDatabase.state === VideoState.PUBLISHED) {
  45       return federateVideoIfNeeded(videoDatabase, false, t)
  46     }
  47
  48     const newState = buildNextVideoState(videoDatabase.state)
  49
  50     if (newState === VideoState.PUBLISHED) {
  51       return moveToPublishedState(videoDatabase, isNewVideo, t)
  52     }
  53
  54     if (newState === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
  55       return moveToExternalStorageState(videoDatabase, isNewVideo, t)
  56     }
  57   })
  58 }
  59
  60 async function moveToExternalStorageState (video: MVideoFullLight, isNewVideo: boolean, transaction: Transaction) {
  61   const videoJobInfo = await VideoJobInfoModel.load(video.id, transaction)
  62   const pendingTranscode = videoJobInfo?.pendingTranscode || 0
  63
  64   // We want to wait all transcoding jobs before moving the video on an external storage
  65   if (pendingTranscode !== 0) return false
  66
  67   await video.setNewState(VideoState.TO_MOVE_TO_EXTERNAL_STORAGE, isNewVideo, transaction)
  68
  69   logger.info('Creating external storage move job for video %s.', video.uuid, { tags: [ video.uuid ] })
  70
  71   try {
  72     await addMoveToObjectStorageJob(video, isNewVideo)
  73
  74     return true
  75   } catch (err) {
  76     logger.error('Cannot add move to object storage job', { err })
  77
  78     return false
  79   }
  80 }
  81
  82 function moveToFailedState (video: MVideoFullLight) {
  83   return sequelizeTypescript.transaction(async t => {
  84     await video.setNewState(VideoState.TRANSCODING_FAILED, false, t)
  85   })
  86 }
  87
  88 // ---------------------------------------------------------------------------
  89
  90 export {
  91   buildNextVideoState,
  92   moveToExternalStorageState,
  93   moveToFailedState,
  94   moveToNextState
  95 }
  96
  97 // ---------------------------------------------------------------------------
  98
  99 async function moveToPublishedState (video: MVideoFullLight, isNewVideo: boolean, transaction: Transaction) {
 100   logger.info('Publishing video %s.', video.uuid, { tags: [ video.uuid ] })
 101
 102   const previousState = video.state
 103   await video.setNewState(VideoState.PUBLISHED, isNewVideo, transaction)
 104
 105   // If the video was not published, we consider it is a new one for other instances
 106   // Live videos are always federated, so it's not a new video
 107   await federateVideoIfNeeded(video, isNewVideo, transaction)
 108
 109   if (isNewVideo) Notifier.Instance.notifyOnNewVideoIfNeeded(video)
 110
 111   if (previousState === VideoState.TO_TRANSCODE) {
 112     Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(video)
 113   }
 114 }