Skip to content

ActivityPub-federated video streaming platform using P2P directly in your web browser

4.6 KB
Raw Blame
import { VideoFileStream, VideoState, VideoStateType } from '@peertube/peertube-models'
import { CONFIG } from '@server/initializers/config.js'
import { VideoJobInfoModel } from '@server/models/video/video-job-info.js'
import { VideoModel } from '@server/models/video/video.js'
import { MVideo, MVideoFile, MVideoUUID } from '@server/types/models/index.js'
import { buildNonDuplicatedFederateVideoJob } from './activitypub/videos/federate.js'
import { buildNonDuplicatedVideoAutomaticTagsJob } from './automatic-tags/automatic-tags.js'
import { CreateJobOptions, CreateJobTypeAndPayload, JobQueue } from './job-queue/job-queue.js'
import { VideoStoryboardJobHandler } from './runners/index.js'
import { createTranscriptionTaskIfNeeded } from './video-captions.js'

export async function buildMoveVideoJob (options: {
  video: MVideoUUID
  type: 'move-to-object-storage' | 'move-to-file-system'

  moveVideoState?: {
    previousVideoState: VideoStateType
  }
}) {
  const { video, moveVideoState, type } = options

  await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingMove')

  return {
    type,
    payload: {
      videoUUID: video.uuid,
      moveVideoState
    }
  }
}

// ---------------------------------------------------------------------------
// Storyboard
// ---------------------------------------------------------------------------

export async function buildLocalStoryboardJobIfNeeded (options: {
  video: MVideo
  federate: boolean
}) {
  const { video, federate } = options

  const hasVideo = await VideoModel.loadHasStream(video.id, VideoFileStream.VIDEO)

  if (hasVideo && CONFIG.STORYBOARDS.ENABLED && !CONFIG.STORYBOARDS.REMOTE_RUNNERS.ENABLED) {
    return {
      type: 'generate-video-storyboard' as 'generate-video-storyboard',
      payload: {
        videoUUID: video.uuid,
        federate
      }
    }
  }

  if (federate === true) {
    return buildNonDuplicatedFederateVideoJob({ video })
  }

  return undefined
}

export async function addRemoteStoryboardJobIfNeeded (video: MVideo) {
  if (CONFIG.STORYBOARDS.ENABLED !== true) return
  if (CONFIG.STORYBOARDS.REMOTE_RUNNERS.ENABLED !== true) return
  if (!await VideoModel.loadHasStream(video.id, VideoFileStream.VIDEO)) return

  return new VideoStoryboardJobHandler().create({ videoUUID: video.uuid })
}

export async function addLocalOrRemoteStoryboardJobIfNeeded (options: {
  video: MVideo
  federate: boolean
}) {
  const { video, federate } = options

  if (CONFIG.STORYBOARDS.ENABLED !== true) return

  if (CONFIG.STORYBOARDS.REMOTE_RUNNERS.ENABLED === true) {
    await addRemoteStoryboardJobIfNeeded(video)
  } else {
    await JobQueue.Instance.createJob(await buildLocalStoryboardJobIfNeeded({ video, federate }))
  }
}

// ---------------------------------------------------------------------------
// Multiple jobs creation
// ---------------------------------------------------------------------------

export async function addVideoJobsAfterCreation (options: {
  video: MVideo
  videoFile: MVideoFile
  generateTranscription: boolean
}) {
  const { video, videoFile, generateTranscription } = options

  const jobs: (CreateJobTypeAndPayload & CreateJobOptions)[] = [
    {
      type: 'manage-video-torrent' as 'manage-video-torrent',
      payload: {
        videoId: video.id,
        videoFileId: videoFile.id,
        action: 'create'
      }
    },

    await buildLocalStoryboardJobIfNeeded({ video, federate: false }),

    // Before the notify/federate jobs so an auto tag block policy is applied before the video is announced
    // And before the transcoding jobs so a plugin auto tagger analyzes the input file while it is still untouched
    buildNonDuplicatedVideoAutomaticTagsJob({ video, moderation: 'apply' }),

    {
      type: 'notify',
      payload: {
        action: 'new-video',
        videoUUID: video.uuid
      }
    },

    buildNonDuplicatedFederateVideoJob({ video })
  ]

  // No transcoding, move the file directly on object storage
  if (video.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
    jobs.push(
      await buildMoveVideoJob({
        type: 'move-to-object-storage',
        video,
        moveVideoState: {
          previousVideoState: undefined
        }
      })
    )
  }

  if (video.state === VideoState.TO_TRANSCODE) {
    jobs.push({
      type: 'transcoding-job-builder' as 'transcoding-job-builder',
      payload: {
        videoUUID: video.uuid,
        optimizeJob: {}
      }
    })
  }

  await JobQueue.Instance.createSequentialJobFlow(...jobs)

  await addRemoteStoryboardJobIfNeeded(video)

  if (generateTranscription === true) {
    await createTranscriptionTaskIfNeeded(video)
  }
}