server/lib/video.ts

   1 import { UploadFiles } from 'express'
   2 import { Transaction } from 'sequelize/types'
   3 import { DEFAULT_AUDIO_RESOLUTION, JOB_PRIORITY } from '@server/initializers/constants'
   4 import { TagModel } from '@server/models/video/tag'
   5 import { VideoModel } from '@server/models/video/video'
   6 import { VideoJobInfoModel } from '@server/models/video/video-job-info'
   7 import { FilteredModelAttributes } from '@server/types'
   8 import { MThumbnail, MUserId, MVideoFile, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
   9 import { ThumbnailType, VideoCreate, VideoPrivacy, VideoState, VideoTranscodingPayload } from '@shared/models'
  10 import { CreateJobOptions, JobQueue } from './job-queue/job-queue'
  11 import { updateVideoMiniatureFromExisting } from './thumbnail'
  12 import { CONFIG } from '@server/initializers/config'
  13
  14 function buildLocalVideoFromReq (videoInfo: VideoCreate, channelId: number): FilteredModelAttributes<VideoModel> {
  15   return {
  16     name: videoInfo.name,
  17     remote: false,
  18     category: videoInfo.category,
  19     licence: videoInfo.licence ?? CONFIG.DEFAULTS.PUBLISH.LICENCE,
  20     language: videoInfo.language,
  21     commentsEnabled: videoInfo.commentsEnabled ?? CONFIG.DEFAULTS.PUBLISH.COMMENTS_ENABLED,
  22     downloadEnabled: videoInfo.downloadEnabled ?? CONFIG.DEFAULTS.PUBLISH.DOWNLOAD_ENABLED,
  23     waitTranscoding: videoInfo.waitTranscoding || false,
  24     nsfw: videoInfo.nsfw || false,
  25     description: videoInfo.description,
  26     support: videoInfo.support,
  27     privacy: videoInfo.privacy || VideoPrivacy.PRIVATE,
  28     channelId: channelId,
  29     originallyPublishedAt: videoInfo.originallyPublishedAt
  30       ? new Date(videoInfo.originallyPublishedAt)
  31       : null
  32   }
  33 }
  34
  35 async function buildVideoThumbnailsFromReq (options: {
  36   video: MVideoThumbnail
  37   files: UploadFiles
  38   fallback: (type: ThumbnailType) => Promise<MThumbnail>
  39   automaticallyGenerated?: boolean
  40 }) {
  41   const { video, files, fallback, automaticallyGenerated } = options
  42
  43   const promises = [
  44     {
  45       type: ThumbnailType.MINIATURE,
  46       fieldName: 'thumbnailfile'
  47     },
  48     {
  49       type: ThumbnailType.PREVIEW,
  50       fieldName: 'previewfile'
  51     }
  52   ].map(p => {
  53     const fields = files?.[p.fieldName]
  54
  55     if (fields) {
  56       return updateVideoMiniatureFromExisting({
  57         inputPath: fields[0].path,
  58         video,
  59         type: p.type,
  60         automaticallyGenerated: automaticallyGenerated || false
  61       })
  62     }
  63
  64     return fallback(p.type)
  65   })
  66
  67   return Promise.all(promises)
  68 }
  69
  70 // ---------------------------------------------------------------------------
  71
  72 async function setVideoTags (options: {
  73   video: MVideoTag
  74   tags: string[]
  75   transaction?: Transaction
  76 }) {
  77   const { video, tags, transaction } = options
  78
  79   const internalTags = tags || []
  80   const tagInstances = await TagModel.findOrCreateTags(internalTags, transaction)
  81
  82   await video.$set('Tags', tagInstances, { transaction })
  83   video.Tags = tagInstances
  84 }
  85
  86 // ---------------------------------------------------------------------------
  87
  88 async function addOptimizeOrMergeAudioJob (options: {
  89   video: MVideoUUID
  90   videoFile: MVideoFile
  91   user: MUserId
  92   isNewVideo?: boolean // Default true
  93 }) {
  94   const { video, videoFile, user, isNewVideo } = options
  95
  96   let dataInput: VideoTranscodingPayload
  97
  98   if (videoFile.isAudio()) {
  99     dataInput = {
 100       type: 'merge-audio-to-webtorrent',
 101       resolution: DEFAULT_AUDIO_RESOLUTION,
 102       videoUUID: video.uuid,
 103       createHLSIfNeeded: true,
 104       isNewVideo
 105     }
 106   } else {
 107     dataInput = {
 108       type: 'optimize-to-webtorrent',
 109       videoUUID: video.uuid,
 110       isNewVideo
 111     }
 112   }
 113
 114   const jobOptions = {
 115     priority: await getTranscodingJobPriority(user)
 116   }
 117
 118   return addTranscodingJob(dataInput, jobOptions)
 119 }
 120
 121 async function addTranscodingJob (payload: VideoTranscodingPayload, options: CreateJobOptions = {}) {
 122   await VideoJobInfoModel.increaseOrCreate(payload.videoUUID, 'pendingTranscode')
 123
 124   return JobQueue.Instance.createJobWithPromise({ type: 'video-transcoding', payload: payload }, options)
 125 }
 126
 127 async function getTranscodingJobPriority (user: MUserId) {
 128   const now = new Date()
 129   const lastWeek = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 7)
 130
 131   const videoUploadedByUser = await VideoModel.countVideosUploadedByUserSince(user.id, lastWeek)
 132
 133   return JOB_PRIORITY.TRANSCODING + videoUploadedByUser
 134 }
 135
 136 // ---------------------------------------------------------------------------
 137
 138 async function addMoveToObjectStorageJob (options: {
 139   video: MVideoUUID
 140   previousVideoState: VideoState
 141   isNewVideo?: boolean // Default true
 142 }) {
 143   const { video, previousVideoState, isNewVideo = true } = options
 144
 145   await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingMove')
 146
 147   const dataInput = { videoUUID: video.uuid, isNewVideo, previousVideoState }
 148   return JobQueue.Instance.createJobWithPromise({ type: 'move-to-object-storage', payload: dataInput })
 149 }
 150
 151 // ---------------------------------------------------------------------------
 152
 153 export {
 154   buildLocalVideoFromReq,
 155   buildVideoThumbnailsFromReq,
 156   setVideoTags,
 157   addOptimizeOrMergeAudioJob,
 158   addTranscodingJob,
 159   addMoveToObjectStorageJob,
 160   getTranscodingJobPriority
 161 }