1 files changed, 99 insertions, 0 deletions

diff --git a/server/lib/video-state.ts b/server/lib/video-state.ts
new file mode 100644
index 000000000..0613d94bf
--- /dev/null
+++ b/server/lib/video-state.ts
@@ -0,0 +1,99 @@
+import { Transaction } from 'sequelize'
+import { logger } from '@server/helpers/logger'
+import { CONFIG } from '@server/initializers/config'
+import { sequelizeTypescript } from '@server/initializers/database'
+import { VideoModel } from '@server/models/video/video'
+import { VideoJobInfoModel } from '@server/models/video/video-job-info'
+import { MVideoFullLight, MVideoUUID } from '@server/types/models'
+import { VideoState } from '@shared/models'
+import { federateVideoIfNeeded } from './activitypub/videos'
+import { Notifier } from './notifier'
+import { addMoveToObjectStorageJob } from './video'
+
+function buildNextVideoState (currentState?: VideoState) {
+  if (currentState === VideoState.PUBLISHED) {
+    throw new Error('Video is already in its final state')
+  }
+
+  if (
+    currentState !== VideoState.TO_TRANSCODE &&
+    currentState !== VideoState.TO_MOVE_TO_EXTERNAL_STORAGE &&
+    CONFIG.TRANSCODING.ENABLED
+  ) {
+    return VideoState.TO_TRANSCODE
+  }
+
+  if (
+    currentState !== VideoState.TO_MOVE_TO_EXTERNAL_STORAGE &&
+    CONFIG.OBJECT_STORAGE.ENABLED
+  ) {
+    return VideoState.TO_MOVE_TO_EXTERNAL_STORAGE
+  }
+
+  return VideoState.PUBLISHED
+}
+
+function moveToNextState (video: MVideoUUID, isNewVideo = true) {
+  return sequelizeTypescript.transaction(async t => {
+    // Maybe the video changed in database, refresh it
+    const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
+    // Video does not exist anymore
+    if (!videoDatabase) return undefined
+
+    // Already in its final state
+    if (videoDatabase.state === VideoState.PUBLISHED) {
+      return federateVideoIfNeeded(videoDatabase, false, t)
+    }
+
+    const newState = buildNextVideoState(videoDatabase.state)
+
+    if (newState === VideoState.PUBLISHED) {
+      return moveToPublishedState(videoDatabase, isNewVideo, t)
+    }
+
+    if (newState === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
+      return moveToExternalStorageState(videoDatabase, isNewVideo, t)
+    }
+  })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+  buildNextVideoState,
+  moveToNextState
+}
+
+// ---------------------------------------------------------------------------
+
+async function moveToPublishedState (video: MVideoFullLight, isNewVideo: boolean, transaction: Transaction) {
+  logger.info('Publishing video %s.', video.uuid, { tags: [ video.uuid ] })
+
+  const previousState = video.state
+  await video.setNewState(VideoState.PUBLISHED, transaction)
+
+  // If the video was not published, we consider it is a new one for other instances
+  // Live videos are always federated, so it's not a new video
+  await federateVideoIfNeeded(video, isNewVideo, transaction)
+
+  Notifier.Instance.notifyOnNewVideoIfNeeded(video)
+
+  if (previousState === VideoState.TO_TRANSCODE) {
+    Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(video)
+  }
+}
+
+async function moveToExternalStorageState (video: MVideoFullLight, isNewVideo: boolean, transaction: Transaction) {
+  const videoJobInfo = await VideoJobInfoModel.load(video.id, transaction)
+  const pendingTranscode = videoJobInfo?.pendingTranscode || 0
+
+  // We want to wait all transcoding jobs before moving the video on an external storage
+  if (pendingTranscode !== 0) return
+
+  await video.setNewState(VideoState.TO_MOVE_TO_EXTERNAL_STORAGE, transaction)
+
+  logger.info('Creating external storage move job for video %s.', video.uuid, { tags: [ video.uuid ] })
+
+  addMoveToObjectStorageJob(video, isNewVideo)
+    .catch(err => logger.error('Cannot add move to object storage job', { err }))
+}