Force live stream termination

[github/Chocobozzz/PeerTube.git] / server / lib / video.ts

diff --git a/server/lib/video.ts b/server/lib/video.ts
index ec4256c1aa077b0efabb373c32f30badab9feb95..588dc553fafb4fe9922a95cc95d6fa288a293e66 100644 (file)
--- a/server/lib/video.ts
+++ b/server/lib/video.ts
@@ -1,15 +1,17 @@
 import { UploadFiles } from 'express'
+import memoizee from 'memoizee'
 import { Transaction } from 'sequelize/types'
-import { DEFAULT_AUDIO_RESOLUTION, JOB_PRIORITY } from '@server/initializers/constants'
+import { CONFIG } from '@server/initializers/config'
+import { MEMOIZE_LENGTH, MEMOIZE_TTL } from '@server/initializers/constants'
 import { TagModel } from '@server/models/video/tag'
 import { VideoModel } from '@server/models/video/video'
 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
 import { FilteredModelAttributes } from '@server/types'
-import { MThumbnail, MUserId, MVideoFile, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
-import { ThumbnailType, VideoCreate, VideoPrivacy, VideoTranscodingPayload } from '@shared/models'
-import { CreateJobOptions, JobQueue } from './job-queue/job-queue'
+import { MThumbnail, MVideoFullLight, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
+import { ManageVideoTorrentPayload, ThumbnailType, VideoCreate, VideoPrivacy, VideoState } from '@shared/models'
+import { CreateJobArgument, JobQueue } from './job-queue/job-queue'
 import { updateVideoMiniatureFromExisting } from './thumbnail'
-import { CONFIG } from '@server/initializers/config'
+import { moveFilesIfPrivacyChanged } from './video-privacy'
 
 function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): FilteredModelAttributes<VideoModel> {
   return {
@@ -25,7 +27,7 @@ function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): Fil
     description: videoInfo.description,
     support: videoInfo.support,
     privacy: videoInfo.privacy || VideoPrivacy.PRIVATE,
-    channelId: channelId,
+    channelId,
     originallyPublishedAt: videoInfo.originallyPublishedAt
       ? new Date(videoInfo.originallyPublishedAt)
       : null
@@ -67,6 +69,8 @@ async function buildVideoThumbnailsFromReq (options: {
   return Promise.all(promises)
 }
 
+// ---------------------------------------------------------------------------
+
 async function setVideoTags (options: {
   video: MVideoTag
   tags: string[]
@@ -81,52 +85,96 @@ async function setVideoTags (options: {
   video.Tags = tagInstances
 }
 
-async function addOptimizeOrMergeAudioJob (video: MVideoUUID, videoFile: MVideoFile, user: MUserId, isNewVideo = true) {
-  let dataInput: VideoTranscodingPayload
+// ---------------------------------------------------------------------------
+
+async function buildMoveToObjectStorageJob (options: {
+  video: MVideoUUID
+  previousVideoState: VideoState
+  isNewVideo?: boolean // Default true
+}) {
+  const { video, previousVideoState, isNewVideo = true } = options
 
-  if (videoFile.isAudio()) {
-    dataInput = {
-      type: 'merge-audio-to-webtorrent',
-      resolution: DEFAULT_AUDIO_RESOLUTION,
-      videoUUID: video.uuid,
-      createHLSIfNeeded: true,
-      isNewVideo
-    }
-  } else {
-    dataInput = {
-      type: 'optimize-to-webtorrent',
+  await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingMove')
+
+  return {
+    type: 'move-to-object-storage' as 'move-to-object-storage',
+    payload: {
       videoUUID: video.uuid,
-      isNewVideo
+      isNewVideo,
+      previousVideoState
     }
   }
+}
 
-  const jobOptions = {
-    priority: await getTranscodingJobPriority(user)
-  }
+// ---------------------------------------------------------------------------
 
-  return addTranscodingJob(dataInput, jobOptions)
-}
+async function getVideoDuration (videoId: number | string) {
+  const video = await VideoModel.load(videoId)
 
-async function addTranscodingJob (payload: VideoTranscodingPayload, options: CreateJobOptions = {}) {
-  await VideoJobInfoModel.increaseOrCreate(payload.videoUUID, 'pendingTranscode')
+  const duration = video.isLive
+    ? undefined
+    : video.duration
 
-  return JobQueue.Instance.createJobWithPromise({ type: 'video-transcoding', payload: payload }, options)
+  return { duration, isLive: video.isLive }
 }
 
-async function addMoveToObjectStorageJob (video: MVideoUUID, isNewVideo = true) {
-  await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingMove')
+const getCachedVideoDuration = memoizee(getVideoDuration, {
+  promise: true,
+  max: MEMOIZE_LENGTH.VIDEO_DURATION,
+  maxAge: MEMOIZE_TTL.VIDEO_DURATION
+})
 
-  const dataInput = { videoUUID: video.uuid, isNewVideo }
-  return JobQueue.Instance.createJobWithPromise({ type: 'move-to-object-storage', payload: dataInput })
-}
+// ---------------------------------------------------------------------------
+
+async function addVideoJobsAfterUpdate (options: {
+  video: MVideoFullLight
+  isNewVideo: boolean
+
+  nameChanged: boolean
+  oldPrivacy: VideoPrivacy
+}) {
+  const { video, nameChanged, oldPrivacy, isNewVideo } = options
+  const jobs: CreateJobArgument[] = []
+
+  const filePathChanged = await moveFilesIfPrivacyChanged(video, oldPrivacy)
 
-async function getTranscodingJobPriority (user: MUserId) {
-  const now = new Date()
-  const lastWeek = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 7)
+  if (!video.isLive && (nameChanged || filePathChanged)) {
+    for (const file of (video.VideoFiles || [])) {
+      const payload: ManageVideoTorrentPayload = { action: 'update-metadata', videoId: video.id, videoFileId: file.id }
 
-  const videoUploadedByUser = await VideoModel.countVideosUploadedByUserSince(user.id, lastWeek)
+      jobs.push({ type: 'manage-video-torrent', payload })
+    }
+
+    const hls = video.getHLSPlaylist()
+
+    for (const file of (hls?.VideoFiles || [])) {
+      const payload: ManageVideoTorrentPayload = { action: 'update-metadata', streamingPlaylistId: hls.id, videoFileId: file.id }
+
+      jobs.push({ type: 'manage-video-torrent', payload })
+    }
+  }
+
+  jobs.push({
+    type: 'federate-video',
+    payload: {
+      videoUUID: video.uuid,
+      isNewVideo
+    }
+  })
+
+  const wasConfidentialVideo = new Set([ VideoPrivacy.PRIVATE, VideoPrivacy.UNLISTED, VideoPrivacy.INTERNAL ]).has(oldPrivacy)
+
+  if (wasConfidentialVideo) {
+    jobs.push({
+      type: 'notify',
+      payload: {
+        action: 'new-video',
+        videoUUID: video.uuid
+      }
+    })
+  }
 
-  return JOB_PRIORITY.TRANSCODING + videoUploadedByUser
+  return JobQueue.Instance.createSequentialJobFlow(...jobs)
 }
 
 // ---------------------------------------------------------------------------
@@ -135,8 +183,7 @@ export {
   buildLocalVideoFromReq,
   buildVideoThumbnailsFromReq,
   setVideoTags,
-  addOptimizeOrMergeAudioJob,
-  addTranscodingJob,
-  addMoveToObjectStorageJob,
-  getTranscodingJobPriority
+  buildMoveToObjectStorageJob,
+  addVideoJobsAfterUpdate,
+  getCachedVideoDuration
 }