X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Flib%2Fvideo.ts;h=6c4f3ce7b0c00826bd8eab505d9d6f02f640b6eb;hb=b42c2c7e89a64ed730d8140840fe74a13c31f2a4;hp=8d9918b2d9315465aab3bd8d5aa12bdf77115c46;hpb=97969c4edf51b37eee691adba43368bb0fbb729b;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/lib/video.ts b/server/lib/video.ts
index 8d9918b2d..6c4f3ce7b 100644
--- a/server/lib/video.ts
+++ b/server/lib/video.ts
@@ -1,36 +1,41 @@
+import { UploadFiles } from 'express'
+import memoizee from 'memoizee'
 import { Transaction } from 'sequelize/types'
-import { sequelizeTypescript } from '@server/initializers/database'
+import { CONFIG } from '@server/initializers/config'
+import { DEFAULT_AUDIO_RESOLUTION, JOB_PRIORITY, 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 { MTag, MThumbnail, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
-import { ThumbnailType, VideoCreate, VideoPrivacy, VideoState } from '@shared/models'
-import { federateVideoIfNeeded } from './activitypub/videos'
-import { Notifier } from './notifier'
-import { createVideoMiniatureFromExisting } from './thumbnail'
+import { MThumbnail, MUserId, MVideoFile, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
+import { ThumbnailType, VideoCreate, VideoPrivacy, VideoState, VideoTranscodingPayload } from '@shared/models'
+import { CreateJobOptions } from './job-queue/job-queue'
+import { updateVideoMiniatureFromExisting } from './thumbnail'
 
 function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): FilteredModelAttributes<VideoModel> {
   return {
     name: videoInfo.name,
     remote: false,
     category: videoInfo.category,
-    licence: videoInfo.licence,
+    licence: videoInfo.licence ?? CONFIG.DEFAULTS.PUBLISH.LICENCE,
     language: videoInfo.language,
-    commentsEnabled: videoInfo.commentsEnabled !== false, // If the value is not "false", the default is "true"
-    downloadEnabled: videoInfo.downloadEnabled !== false,
+    commentsEnabled: videoInfo.commentsEnabled ?? CONFIG.DEFAULTS.PUBLISH.COMMENTS_ENABLED,
+    downloadEnabled: videoInfo.downloadEnabled ?? CONFIG.DEFAULTS.PUBLISH.DOWNLOAD_ENABLED,
     waitTranscoding: videoInfo.waitTranscoding || false,
     nsfw: videoInfo.nsfw || false,
     description: videoInfo.description,
     support: videoInfo.support,
     privacy: videoInfo.privacy || VideoPrivacy.PRIVATE,
-    channelId: channelId,
+    channelId,
     originallyPublishedAt: videoInfo.originallyPublishedAt
+      ? new Date(videoInfo.originallyPublishedAt)
+      : null
   }
 }
 
 async function buildVideoThumbnailsFromReq (options: {
   video: MVideoThumbnail
-  files: { [fieldname: string]: Express.Multer.File[] } | Express.Multer.File[]
+  files: UploadFiles
   fallback: (type: ThumbnailType) => Promise<MThumbnail>
   automaticallyGenerated?: boolean
 }) {
@@ -49,7 +54,7 @@ async function buildVideoThumbnailsFromReq (options: {
     const fields = files?.[p.fieldName]
 
     if (fields) {
-      return createVideoMiniatureFromExisting({
+      return updateVideoMiniatureFromExisting({
         inputPath: fields[0].path,
         video,
         type: p.type,
@@ -63,52 +68,122 @@ async function buildVideoThumbnailsFromReq (options: {
   return Promise.all(promises)
 }
 
+// ---------------------------------------------------------------------------
+
 async function setVideoTags (options: {
   video: MVideoTag
   tags: string[]
   transaction?: Transaction
-  defaultValue?: MTag[]
 }) {
-  const { video, tags, transaction, defaultValue } = options
-  // Set tags to the video
-  if (tags) {
-    const tagInstances = await TagModel.findOrCreateTags(tags, transaction)
+  const { video, tags, transaction } = options
+
+  const internalTags = tags || []
+  const tagInstances = await TagModel.findOrCreateTags(internalTags, transaction)
+
+  await video.$set('Tags', tagInstances, { transaction })
+  video.Tags = tagInstances
+}
+
+// ---------------------------------------------------------------------------
+
+async function buildOptimizeOrMergeAudioJob (options: {
+  video: MVideoUUID
+  videoFile: MVideoFile
+  user: MUserId
+  isNewVideo?: boolean // Default true
+}) {
+  const { video, videoFile, user, isNewVideo } = options
 
-    await video.$set('Tags', tagInstances, { transaction })
-    video.Tags = tagInstances
+  let payload: VideoTranscodingPayload
+
+  if (videoFile.isAudio()) {
+    payload = {
+      type: 'merge-audio-to-webtorrent',
+      resolution: DEFAULT_AUDIO_RESOLUTION,
+      videoUUID: video.uuid,
+      createHLSIfNeeded: true,
+      isNewVideo
+    }
   } else {
-    video.Tags = defaultValue || []
+    payload = {
+      type: 'optimize-to-webtorrent',
+      videoUUID: video.uuid,
+      isNewVideo
+    }
+  }
+
+  await VideoJobInfoModel.increaseOrCreate(payload.videoUUID, 'pendingTranscode')
+
+  return {
+    type: 'video-transcoding' as 'video-transcoding',
+    priority: await getTranscodingJobPriority(user),
+    payload
   }
 }
 
-async function publishAndFederateIfNeeded (video: MVideoUUID, wasLive = false) {
-  const result = await 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
+async function buildTranscodingJob (payload: VideoTranscodingPayload, options: CreateJobOptions = {}) {
+  await VideoJobInfoModel.increaseOrCreate(payload.videoUUID, 'pendingTranscode')
+
+  return { type: 'video-transcoding' as 'video-transcoding', payload, ...options }
+}
+
+async function getTranscodingJobPriority (user: MUserId) {
+  const now = new Date()
+  const lastWeek = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 7)
 
-    // We transcoded the video file in another format, now we can publish it
-    const videoPublished = await videoDatabase.publishIfNeededAndSave(t)
+  const videoUploadedByUser = await VideoModel.countVideosUploadedByUserSince(user.id, lastWeek)
 
-    // 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(videoDatabase, !wasLive && videoPublished, t)
+  return JOB_PRIORITY.TRANSCODING + videoUploadedByUser
+}
 
-    return { videoDatabase, videoPublished }
-  })
+// ---------------------------------------------------------------------------
 
-  if (result?.videoPublished) {
-    Notifier.Instance.notifyOnNewVideoIfNeeded(result.videoDatabase)
-    Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(result.videoDatabase)
+async function buildMoveToObjectStorageJob (options: {
+  video: MVideoUUID
+  previousVideoState: VideoState
+  isNewVideo?: boolean // Default true
+}) {
+  const { video, previousVideoState, isNewVideo = true } = options
+
+  await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingMove')
+
+  return {
+    type: 'move-to-object-storage' as 'move-to-object-storage',
+    payload: {
+      videoUUID: video.uuid,
+      isNewVideo,
+      previousVideoState
+    }
   }
 }
 
 // ---------------------------------------------------------------------------
 
+async function getVideoDuration (videoId: number | string) {
+  const video = await VideoModel.load(videoId)
+
+  const duration = video.isLive
+    ? undefined
+    : video.duration
+
+  return { duration, isLive: video.isLive }
+}
+
+const getCachedVideoDuration = memoizee(getVideoDuration, {
+  promise: true,
+  max: MEMOIZE_LENGTH.VIDEO_DURATION,
+  maxAge: MEMOIZE_TTL.VIDEO_DURATION
+})
+
+// ---------------------------------------------------------------------------
+
 export {
   buildLocalVideoFromReq,
-  publishAndFederateIfNeeded,
   buildVideoThumbnailsFromReq,
-  setVideoTags
+  setVideoTags,
+  buildOptimizeOrMergeAudioJob,
+  buildTranscodingJob,
+  buildMoveToObjectStorageJob,
+  getTranscodingJobPriority,
+  getCachedVideoDuration
 }