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 { MVideo, 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 moveToFailedTranscodingState (video: MVideo) {
  83   if (video.state === VideoState.TRANSCODING_FAILED) return
  84
  85   return video.setNewState(VideoState.TRANSCODING_FAILED, false, undefined)
  86 }
  87
  88 function moveToFailedMoveToObjectStorageState (video: MVideo) {
  89   if (video.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE_FAILED) return
  90
  91   return video.setNewState(VideoState.TO_MOVE_TO_EXTERNAL_STORAGE_FAILED, false, undefined)
  92 }
  93
  94 // ---------------------------------------------------------------------------
  95
  96 export {
  97   buildNextVideoState,
  98   moveToExternalStorageState,
  99   moveToFailedTranscodingState,
 100   moveToFailedMoveToObjectStorageState,
 101   moveToNextState
 102 }
 103
 104 // ---------------------------------------------------------------------------
 105
 106 async function moveToPublishedState (video: MVideoFullLight, isNewVideo: boolean, transaction: Transaction) {
 107   logger.info('Publishing video %s.', video.uuid, { tags: [ video.uuid ] })
 108
 109   const previousState = video.state
 110   await video.setNewState(VideoState.PUBLISHED, isNewVideo, transaction)
 111
 112   // If the video was not published, we consider it is a new one for other instances
 113   // Live videos are always federated, so it's not a new video
 114   await federateVideoIfNeeded(video, isNewVideo, transaction)
 115
 116   if (!isNewVideo) return
 117
 118   Notifier.Instance.notifyOnNewVideoIfNeeded(video)
 119
 120   if (previousState === VideoState.TO_TRANSCODE) {
 121     Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(video)
 122   }
 123 }