PeerTube/server/core/lib/runners/job-handlers/video-studio-transcoding-jo...

158 lines
4.3 KiB
TypeScript

import {
RunnerJobState,
RunnerJobStateType,
RunnerJobStudioTranscodingPayload,
RunnerJobUpdatePayload,
RunnerJobVideoStudioTranscodingPrivatePayload,
VideoState,
VideoStudioTaskPayload,
VideoStudioTranscodingSuccess,
isVideoStudioTaskIntro,
isVideoStudioTaskOutro,
isVideoStudioTaskWatermark
} from '@peertube/peertube-models'
import { buildUUID } from '@peertube/peertube-node-utils'
import { logger } from '@server/helpers/logger.js'
import { onVideoStudioEnded, safeCleanupStudioTMPFiles } from '@server/lib/video-studio.js'
import { MVideo } from '@server/types/models/index.js'
import { MRunnerJob } from '@server/types/models/runners/index.js'
import { basename } from 'path'
import { generateRunnerEditionTranscodingVideoInputFileUrl, generateRunnerTranscodingVideoInputFileUrl } from '../runner-urls.js'
import { AbstractJobHandler } from './abstract-job-handler.js'
import { loadRunnerVideo } from './shared/utils.js'
type CreateOptions = {
video: MVideo
tasks: VideoStudioTaskPayload[]
priority: number
}
// eslint-disable-next-line max-len
export class VideoStudioTranscodingJobHandler extends AbstractJobHandler<CreateOptions, RunnerJobUpdatePayload, VideoStudioTranscodingSuccess> {
async create (options: CreateOptions) {
const { video, priority, tasks } = options
const jobUUID = buildUUID()
const payload: RunnerJobStudioTranscodingPayload = {
input: {
videoFileUrl: generateRunnerTranscodingVideoInputFileUrl(jobUUID, video.uuid)
},
tasks: tasks.map(t => {
if (isVideoStudioTaskIntro(t) || isVideoStudioTaskOutro(t)) {
return {
...t,
options: {
...t.options,
file: generateRunnerEditionTranscodingVideoInputFileUrl(jobUUID, video.uuid, basename(t.options.file))
}
}
}
if (isVideoStudioTaskWatermark(t)) {
return {
...t,
options: {
...t.options,
file: generateRunnerEditionTranscodingVideoInputFileUrl(jobUUID, video.uuid, basename(t.options.file))
}
}
}
return t
})
}
const privatePayload: RunnerJobVideoStudioTranscodingPrivatePayload = {
videoUUID: video.uuid,
originalTasks: tasks
}
const job = await this.createRunnerJob({
type: 'video-studio-transcoding',
jobUUID,
payload,
privatePayload,
priority
})
return job
}
// ---------------------------------------------------------------------------
protected isAbortSupported () {
return true
}
protected specificUpdate (_options: {
runnerJob: MRunnerJob
}) {
// empty
}
protected specificAbort (_options: {
runnerJob: MRunnerJob
}) {
// empty
}
protected async specificComplete (options: {
runnerJob: MRunnerJob
resultPayload: VideoStudioTranscodingSuccess
}) {
const { runnerJob, resultPayload } = options
const privatePayload = runnerJob.privatePayload as RunnerJobVideoStudioTranscodingPrivatePayload
const video = await loadRunnerVideo(runnerJob, this.lTags)
if (!video) {
await safeCleanupStudioTMPFiles(privatePayload.originalTasks)
}
const videoFilePath = resultPayload.videoFile as string
await onVideoStudioEnded({ video, editionResultPath: videoFilePath, tasks: privatePayload.originalTasks })
logger.info(
'Runner video edition transcoding job %s for %s ended.',
runnerJob.uuid, video.uuid, this.lTags(video.uuid, runnerJob.uuid)
)
}
protected specificError (options: {
runnerJob: MRunnerJob
nextState: RunnerJobStateType
}) {
if (options.nextState === RunnerJobState.ERRORED) {
return this.specificErrorOrCancel(options)
}
return Promise.resolve()
}
protected specificCancel (options: {
runnerJob: MRunnerJob
}) {
return this.specificErrorOrCancel(options)
}
private async specificErrorOrCancel (options: {
runnerJob: MRunnerJob
}) {
const { runnerJob } = options
const payload = runnerJob.privatePayload as RunnerJobVideoStudioTranscodingPrivatePayload
await safeCleanupStudioTMPFiles(payload.originalTasks)
const video = await loadRunnerVideo(options.runnerJob, this.lTags)
if (!video) return
return video.setNewState(VideoState.PUBLISHED, false, undefined)
}
}