Migrate server to ESM

Sorry for the very big commit that may lead to git log issues and merge
conflicts, but it's a major step forward:

 * Server can be faster at startup because imports() are async and we can
   easily lazy import big modules
 * Angular doesn't seem to support ES import (with .js extension), so we
   had to correctly organize peertube into a monorepo:
    * Use yarn workspace feature
    * Use typescript reference projects for dependencies
    * Shared projects have been moved into "packages", each one is now a
      node module (with a dedicated package.json/tsconfig.json)
    * server/tools have been moved into apps/ and is now a dedicated app
      bundled and published on NPM so users don't have to build peertube
      cli tools manually
    * server/tests have been moved into packages/ so we don't compile
      them every time we want to run the server
 * Use isolatedModule option:
   * Had to move from const enum to const
     (https://www.typescriptlang.org/docs/handbook/enums.html#objects-vs-enums)
   * Had to explictely specify "type" imports when used in decorators
 * Prefer tsx (that uses esbuild under the hood) instead of ts-node to
   load typescript files (tests with mocha or scripts):
     * To reduce test complexity as esbuild doesn't support decorator
       metadata, we only test server files that do not import server
       models
     * We still build tests files into js files for a faster CI
 * Remove unmaintained peertube CLI import script
 * Removed some barrels to speed up execution (less imports)

8 files changed, 0 insertions, 859 deletions

diff --git a/packages/peertube-runner/server/process/index.ts b/packages/peertube-runner/server/process/index.ts
deleted file mode 100644
index 6caedbdaf..000000000
--- a/packages/peertube-runner/server/process/index.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-export * from './shared'
-export * from './process'
diff --git a/packages/peertube-runner/server/process/process.ts b/packages/peertube-runner/server/process/process.ts
deleted file mode 100644
index 1caafda8c..000000000
--- a/packages/peertube-runner/server/process/process.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-import { logger } from 'packages/peertube-runner/shared/logger'
-import {
-  RunnerJobLiveRTMPHLSTranscodingPayload,
-  RunnerJobStudioTranscodingPayload,
-  RunnerJobVODAudioMergeTranscodingPayload,
-  RunnerJobVODHLSTranscodingPayload,
-  RunnerJobVODWebVideoTranscodingPayload
-} from '@shared/models'
-import { processAudioMergeTranscoding, processHLSTranscoding, ProcessOptions, processWebVideoTranscoding } from './shared'
-import { ProcessLiveRTMPHLSTranscoding } from './shared/process-live'
-import { processStudioTranscoding } from './shared/process-studio'
-
-export async function processJob (options: ProcessOptions) {
-  const { server, job } = options
-
-  logger.info(`[${server.url}] Processing job of type ${job.type}: ${job.uuid}`, { payload: job.payload })
-
-  if (job.type === 'vod-audio-merge-transcoding') {
-    await processAudioMergeTranscoding(options as ProcessOptions<RunnerJobVODAudioMergeTranscodingPayload>)
-  } else if (job.type === 'vod-web-video-transcoding') {
-    await processWebVideoTranscoding(options as ProcessOptions<RunnerJobVODWebVideoTranscodingPayload>)
-  } else if (job.type === 'vod-hls-transcoding') {
-    await processHLSTranscoding(options as ProcessOptions<RunnerJobVODHLSTranscodingPayload>)
-  } else if (job.type === 'live-rtmp-hls-transcoding') {
-    await new ProcessLiveRTMPHLSTranscoding(options as ProcessOptions<RunnerJobLiveRTMPHLSTranscodingPayload>).process()
-  } else if (job.type === 'video-studio-transcoding') {
-    await processStudioTranscoding(options as ProcessOptions<RunnerJobStudioTranscodingPayload>)
-  } else {
-    logger.error(`Unknown job ${job.type} to process`)
-    return
-  }
-
-  logger.info(`[${server.url}] Finished processing job of type ${job.type}: ${job.uuid}`)
-}
diff --git a/packages/peertube-runner/server/process/shared/common.ts b/packages/peertube-runner/server/process/shared/common.ts
deleted file mode 100644
index a9b37bbc4..000000000
--- a/packages/peertube-runner/server/process/shared/common.ts
+++ /dev/null
@@ -1,106 +0,0 @@
-import { remove } from 'fs-extra'
-import { ConfigManager, downloadFile, logger } from 'packages/peertube-runner/shared'
-import { join } from 'path'
-import { buildUUID } from '@shared/extra-utils'
-import { FFmpegEdition, FFmpegLive, FFmpegVOD, getDefaultAvailableEncoders, getDefaultEncodersToTry } from '@shared/ffmpeg'
-import { RunnerJob, RunnerJobPayload } from '@shared/models'
-import { PeerTubeServer } from '@shared/server-commands'
-import { getTranscodingLogger } from './transcoding-logger'
-
-export type JobWithToken <T extends RunnerJobPayload = RunnerJobPayload> = RunnerJob<T> & { jobToken: string }
-
-export type ProcessOptions <T extends RunnerJobPayload = RunnerJobPayload> = {
-  server: PeerTubeServer
-  job: JobWithToken<T>
-  runnerToken: string
-}
-
-export async function downloadInputFile (options: {
-  url: string
-  job: JobWithToken
-  runnerToken: string
-}) {
-  const { url, job, runnerToken } = options
-  const destination = join(ConfigManager.Instance.getTranscodingDirectory(), buildUUID())
-
-  try {
-    await downloadFile({ url, jobToken: job.jobToken, runnerToken, destination })
-  } catch (err) {
-    remove(destination)
-      .catch(err => logger.error({ err }, `Cannot remove ${destination}`))
-
-    throw err
-  }
-
-  return destination
-}
-
-export function scheduleTranscodingProgress (options: {
-  server: PeerTubeServer
-  runnerToken: string
-  job: JobWithToken
-  progressGetter: () => number
-}) {
-  const { job, server, progressGetter, runnerToken } = options
-
-  const updateInterval = ConfigManager.Instance.isTestInstance()
-    ? 500
-    : 60000
-
-  const update = () => {
-    server.runnerJobs.update({ jobToken: job.jobToken, jobUUID: job.uuid, runnerToken, progress: progressGetter() })
-      .catch(err => logger.error({ err }, 'Cannot send job progress'))
-  }
-
-  const interval = setInterval(() => {
-    update()
-  }, updateInterval)
-
-  update()
-
-  return interval
-}
-
-// ---------------------------------------------------------------------------
-
-export function buildFFmpegVOD (options: {
-  onJobProgress: (progress: number) => void
-}) {
-  const { onJobProgress } = options
-
-  return new FFmpegVOD({
-    ...getCommonFFmpegOptions(),
-
-    updateJobProgress: arg => {
-      const progress = arg < 0 || arg > 100
-        ? undefined
-        : arg
-
-      onJobProgress(progress)
-    }
-  })
-}
-
-export function buildFFmpegLive () {
-  return new FFmpegLive(getCommonFFmpegOptions())
-}
-
-export function buildFFmpegEdition () {
-  return new FFmpegEdition(getCommonFFmpegOptions())
-}
-
-function getCommonFFmpegOptions () {
-  const config = ConfigManager.Instance.getConfig()
-
-  return {
-    niceness: config.ffmpeg.nice,
-    threads: config.ffmpeg.threads,
-    tmpDirectory: ConfigManager.Instance.getTranscodingDirectory(),
-    profile: 'default',
-    availableEncoders: {
-      available: getDefaultAvailableEncoders(),
-      encodersToTry: getDefaultEncodersToTry()
-    },
-    logger: getTranscodingLogger()
-  }
-}
diff --git a/packages/peertube-runner/server/process/shared/index.ts b/packages/peertube-runner/server/process/shared/index.ts
deleted file mode 100644
index 556c51365..000000000
--- a/packages/peertube-runner/server/process/shared/index.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from './common'
-export * from './process-vod'
-export * from './transcoding-logger'
diff --git a/packages/peertube-runner/server/process/shared/process-live.ts b/packages/peertube-runner/server/process/shared/process-live.ts
deleted file mode 100644
index e1fc0e34e..000000000
--- a/packages/peertube-runner/server/process/shared/process-live.ts
+++ /dev/null
@@ -1,338 +0,0 @@
-import { FSWatcher, watch } from 'chokidar'
-import { FfmpegCommand } from 'fluent-ffmpeg'
-import { ensureDir, remove } from 'fs-extra'
-import { logger } from 'packages/peertube-runner/shared'
-import { basename, join } from 'path'
-import { wait } from '@shared/core-utils'
-import { buildUUID } from '@shared/extra-utils'
-import { ffprobePromise, getVideoStreamBitrate, getVideoStreamDimensionsInfo, hasAudioStream } from '@shared/ffmpeg'
-import {
-  LiveRTMPHLSTranscodingSuccess,
-  LiveRTMPHLSTranscodingUpdatePayload,
-  PeerTubeProblemDocument,
-  RunnerJobLiveRTMPHLSTranscodingPayload,
-  ServerErrorCode
-} from '@shared/models'
-import { ConfigManager } from '../../../shared/config-manager'
-import { buildFFmpegLive, ProcessOptions } from './common'
-
-export class ProcessLiveRTMPHLSTranscoding {
-
-  private readonly outputPath: string
-  private readonly fsWatchers: FSWatcher[] = []
-
-  // Playlist name -> chunks
-  private readonly pendingChunksPerPlaylist = new Map<string, string[]>()
-
-  private readonly playlistsCreated = new Set<string>()
-  private allPlaylistsCreated = false
-
-  private ffmpegCommand: FfmpegCommand
-
-  private ended = false
-  private errored = false
-
-  constructor (private readonly options: ProcessOptions<RunnerJobLiveRTMPHLSTranscodingPayload>) {
-    this.outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), buildUUID())
-
-    logger.debug(`Using ${this.outputPath} to process live rtmp hls transcoding job ${options.job.uuid}`)
-  }
-
-  process () {
-    const job = this.options.job
-    const payload = job.payload
-
-    return new Promise<void>(async (res, rej) => {
-      try {
-        await ensureDir(this.outputPath)
-
-        logger.info(`Probing ${payload.input.rtmpUrl}`)
-        const probe = await ffprobePromise(payload.input.rtmpUrl)
-        logger.info({ probe }, `Probed ${payload.input.rtmpUrl}`)
-
-        const hasAudio = await hasAudioStream(payload.input.rtmpUrl, probe)
-        const bitrate = await getVideoStreamBitrate(payload.input.rtmpUrl, probe)
-        const { ratio } = await getVideoStreamDimensionsInfo(payload.input.rtmpUrl, probe)
-
-        const m3u8Watcher = watch(this.outputPath + '/*.m3u8')
-        this.fsWatchers.push(m3u8Watcher)
-
-        const tsWatcher = watch(this.outputPath + '/*.ts')
-        this.fsWatchers.push(tsWatcher)
-
-        m3u8Watcher.on('change', p => {
-          logger.debug(`${p} m3u8 playlist changed`)
-        })
-
-        m3u8Watcher.on('add', p => {
-          this.playlistsCreated.add(p)
-
-          if (this.playlistsCreated.size === this.options.job.payload.output.toTranscode.length + 1) {
-            this.allPlaylistsCreated = true
-            logger.info('All m3u8 playlists are created.')
-          }
-        })
-
-        tsWatcher.on('add', async p => {
-          try {
-            await this.sendPendingChunks()
-          } catch (err) {
-            this.onUpdateError({ err, rej, res })
-          }
-
-          const playlistName = this.getPlaylistIdFromTS(p)
-
-          const pendingChunks = this.pendingChunksPerPlaylist.get(playlistName) || []
-          pendingChunks.push(p)
-
-          this.pendingChunksPerPlaylist.set(playlistName, pendingChunks)
-        })
-
-        tsWatcher.on('unlink', p => {
-          this.sendDeletedChunkUpdate(p)
-            .catch(err => this.onUpdateError({ err, rej, res }))
-        })
-
-        this.ffmpegCommand = await buildFFmpegLive().getLiveTranscodingCommand({
-          inputUrl: payload.input.rtmpUrl,
-
-          outPath: this.outputPath,
-          masterPlaylistName: 'master.m3u8',
-
-          segmentListSize: payload.output.segmentListSize,
-          segmentDuration: payload.output.segmentDuration,
-
-          toTranscode: payload.output.toTranscode,
-
-          bitrate,
-          ratio,
-
-          hasAudio
-        })
-
-        logger.info(`Running live transcoding for ${payload.input.rtmpUrl}`)
-
-        this.ffmpegCommand.on('error', (err, stdout, stderr) => {
-          this.onFFmpegError({ err, stdout, stderr })
-
-          res()
-        })
-
-        this.ffmpegCommand.on('end', () => {
-          this.onFFmpegEnded()
-            .catch(err => logger.error({ err }, 'Error in FFmpeg end handler'))
-
-          res()
-        })
-
-        this.ffmpegCommand.run()
-      } catch (err) {
-        rej(err)
-      }
-    })
-  }
-
-  // ---------------------------------------------------------------------------
-
-  private onUpdateError (options: {
-    err: Error
-    res: () => void
-    rej: (reason?: any) => void
-  }) {
-    const { err, res, rej } = options
-
-    if (this.errored) return
-    if (this.ended) return
-
-    this.errored = true
-
-    this.ffmpegCommand.kill('SIGINT')
-
-    const type = ((err as any).res?.body as PeerTubeProblemDocument)?.code
-    if (type === ServerErrorCode.RUNNER_JOB_NOT_IN_PROCESSING_STATE) {
-      logger.info({ err }, 'Stopping transcoding as the job is not in processing state anymore')
-
-      res()
-    } else {
-      logger.error({ err }, 'Cannot send update after added/deleted chunk, stopping live transcoding')
-
-      this.sendError(err)
-        .catch(subErr => logger.error({ err: subErr }, 'Cannot send error'))
-
-      rej(err)
-    }
-
-    this.cleanup()
-  }
-
-  // ---------------------------------------------------------------------------
-
-  private onFFmpegError (options: {
-    err: any
-    stdout: string
-    stderr: string
-  }) {
-    const { err, stdout, stderr } = options
-
-    // Don't care that we killed the ffmpeg process
-    if (err?.message?.includes('Exiting normally')) return
-    if (this.errored) return
-    if (this.ended) return
-
-    this.errored = true
-
-    logger.error({ err, stdout, stderr }, 'FFmpeg transcoding error.')
-
-    this.sendError(err)
-      .catch(subErr => logger.error({ err: subErr }, 'Cannot send error'))
-
-    this.cleanup()
-  }
-
-  private async sendError (err: Error) {
-    await this.options.server.runnerJobs.error({
-      jobToken: this.options.job.jobToken,
-      jobUUID: this.options.job.uuid,
-      runnerToken: this.options.runnerToken,
-      message: err.message
-    })
-  }
-
-  // ---------------------------------------------------------------------------
-
-  private async onFFmpegEnded () {
-    if (this.ended) return
-
-    this.ended = true
-    logger.info('FFmpeg ended, sending success to server')
-
-    // Wait last ffmpeg chunks generation
-    await wait(1500)
-
-    this.sendSuccess()
-      .catch(err => logger.error({ err }, 'Cannot send success'))
-
-    this.cleanup()
-  }
-
-  private async sendSuccess () {
-    const successBody: LiveRTMPHLSTranscodingSuccess = {}
-
-    await this.options.server.runnerJobs.success({
-      jobToken: this.options.job.jobToken,
-      jobUUID: this.options.job.uuid,
-      runnerToken: this.options.runnerToken,
-      payload: successBody
-    })
-  }
-
-  // ---------------------------------------------------------------------------
-
-  private sendDeletedChunkUpdate (deletedChunk: string): Promise<any> {
-    if (this.ended) return Promise.resolve()
-
-    logger.debug(`Sending removed live chunk ${deletedChunk} update`)
-
-    const videoChunkFilename = basename(deletedChunk)
-
-    let payload: LiveRTMPHLSTranscodingUpdatePayload = {
-      type: 'remove-chunk',
-      videoChunkFilename
-    }
-
-    if (this.allPlaylistsCreated) {
-      const playlistName = this.getPlaylistName(videoChunkFilename)
-
-      payload = {
-        ...payload,
-        masterPlaylistFile: join(this.outputPath, 'master.m3u8'),
-        resolutionPlaylistFilename: playlistName,
-        resolutionPlaylistFile: join(this.outputPath, playlistName)
-      }
-    }
-
-    return this.updateWithRetry(payload)
-  }
-
-  private async sendPendingChunks (): Promise<any> {
-    if (this.ended) return Promise.resolve()
-
-    const promises: Promise<any>[] = []
-
-    for (const playlist of this.pendingChunksPerPlaylist.keys()) {
-      for (const chunk of this.pendingChunksPerPlaylist.get(playlist)) {
-        logger.debug(`Sending added live chunk ${chunk} update`)
-
-        const videoChunkFilename = basename(chunk)
-
-        let payload: LiveRTMPHLSTranscodingUpdatePayload = {
-          type: 'add-chunk',
-          videoChunkFilename,
-          videoChunkFile: chunk
-        }
-
-        if (this.allPlaylistsCreated) {
-          const playlistName = this.getPlaylistName(videoChunkFilename)
-
-          payload = {
-            ...payload,
-            masterPlaylistFile: join(this.outputPath, 'master.m3u8'),
-            resolutionPlaylistFilename: playlistName,
-            resolutionPlaylistFile: join(this.outputPath, playlistName)
-          }
-        }
-
-        promises.push(this.updateWithRetry(payload))
-      }
-
-      this.pendingChunksPerPlaylist.set(playlist, [])
-    }
-
-    await Promise.all(promises)
-  }
-
-  private async updateWithRetry (payload: LiveRTMPHLSTranscodingUpdatePayload, currentTry = 1): Promise<any> {
-    if (this.ended || this.errored) return
-
-    try {
-      await this.options.server.runnerJobs.update({
-        jobToken: this.options.job.jobToken,
-        jobUUID: this.options.job.uuid,
-        runnerToken: this.options.runnerToken,
-        payload
-      })
-    } catch (err) {
-      if (currentTry >= 3) throw err
-      if ((err.res?.body as PeerTubeProblemDocument)?.code === ServerErrorCode.RUNNER_JOB_NOT_IN_PROCESSING_STATE) throw err
-
-      logger.warn({ err }, 'Will retry update after error')
-      await wait(250)
-
-      return this.updateWithRetry(payload, currentTry + 1)
-    }
-  }
-
-  private getPlaylistName (videoChunkFilename: string) {
-    return `${videoChunkFilename.split('-')[0]}.m3u8`
-  }
-
-  private getPlaylistIdFromTS (segmentPath: string) {
-    const playlistIdMatcher = /^([\d+])-/
-
-    return basename(segmentPath).match(playlistIdMatcher)[1]
-  }
-
-  // ---------------------------------------------------------------------------
-
-  private cleanup () {
-    logger.debug(`Cleaning up job ${this.options.job.uuid}`)
-
-    for (const fsWatcher of this.fsWatchers) {
-      fsWatcher.close()
-        .catch(err => logger.error({ err }, 'Cannot close watcher'))
-    }
-
-    remove(this.outputPath)
-      .catch(err => logger.error({ err }, `Cannot remove ${this.outputPath}`))
-  }
-}
diff --git a/packages/peertube-runner/server/process/shared/process-studio.ts b/packages/peertube-runner/server/process/shared/process-studio.ts
deleted file mode 100644
index 7bb209e80..000000000
--- a/packages/peertube-runner/server/process/shared/process-studio.ts
+++ /dev/null
@@ -1,165 +0,0 @@
-import { remove } from 'fs-extra'
-import { logger } from 'packages/peertube-runner/shared'
-import { join } from 'path'
-import { pick } from '@shared/core-utils'
-import { buildUUID } from '@shared/extra-utils'
-import {
-  RunnerJobStudioTranscodingPayload,
-  VideoStudioTask,
-  VideoStudioTaskCutPayload,
-  VideoStudioTaskIntroPayload,
-  VideoStudioTaskOutroPayload,
-  VideoStudioTaskPayload,
-  VideoStudioTaskWatermarkPayload,
-  VideoStudioTranscodingSuccess
-} from '@shared/models'
-import { ConfigManager } from '../../../shared/config-manager'
-import { buildFFmpegEdition, downloadInputFile, JobWithToken, ProcessOptions, scheduleTranscodingProgress } from './common'
-
-export async function processStudioTranscoding (options: ProcessOptions<RunnerJobStudioTranscodingPayload>) {
-  const { server, job, runnerToken } = options
-  const payload = job.payload
-
-  let inputPath: string
-  let outputPath: string
-  let tmpInputFilePath: string
-
-  let tasksProgress = 0
-
-  const updateProgressInterval = scheduleTranscodingProgress({
-    job,
-    server,
-    runnerToken,
-    progressGetter: () => tasksProgress
-  })
-
-  try {
-    logger.info(`Downloading input file ${payload.input.videoFileUrl} for job ${job.jobToken}`)
-
-    inputPath = await downloadInputFile({ url: payload.input.videoFileUrl, runnerToken, job })
-    tmpInputFilePath = inputPath
-
-    logger.info(`Input file ${payload.input.videoFileUrl} downloaded for job ${job.jobToken}. Running studio transcoding tasks.`)
-
-    for (const task of payload.tasks) {
-      const outputFilename = 'output-edition-' + buildUUID() + '.mp4'
-      outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), outputFilename)
-
-      await processTask({
-        inputPath: tmpInputFilePath,
-        outputPath,
-        task,
-        job,
-        runnerToken
-      })
-
-      if (tmpInputFilePath) await remove(tmpInputFilePath)
-
-      // For the next iteration
-      tmpInputFilePath = outputPath
-
-      tasksProgress += Math.floor(100 / payload.tasks.length)
-    }
-
-    const successBody: VideoStudioTranscodingSuccess = {
-      videoFile: outputPath
-    }
-
-    await server.runnerJobs.success({
-      jobToken: job.jobToken,
-      jobUUID: job.uuid,
-      runnerToken,
-      payload: successBody
-    })
-  } finally {
-    if (tmpInputFilePath) await remove(tmpInputFilePath)
-    if (outputPath) await remove(outputPath)
-    if (updateProgressInterval) clearInterval(updateProgressInterval)
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Private
-// ---------------------------------------------------------------------------
-
-type TaskProcessorOptions <T extends VideoStudioTaskPayload = VideoStudioTaskPayload> = {
-  inputPath: string
-  outputPath: string
-  task: T
-  runnerToken: string
-  job: JobWithToken
-}
-
-const taskProcessors: { [id in VideoStudioTask['name']]: (options: TaskProcessorOptions) => Promise<any> } = {
-  'add-intro': processAddIntroOutro,
-  'add-outro': processAddIntroOutro,
-  'cut': processCut,
-  'add-watermark': processAddWatermark
-}
-
-async function processTask (options: TaskProcessorOptions) {
-  const { task } = options
-
-  const processor = taskProcessors[options.task.name]
-  if (!process) throw new Error('Unknown task ' + task.name)
-
-  return processor(options)
-}
-
-async function processAddIntroOutro (options: TaskProcessorOptions<VideoStudioTaskIntroPayload | VideoStudioTaskOutroPayload>) {
-  const { inputPath, task, runnerToken, job } = options
-
-  logger.debug('Adding intro/outro to ' + inputPath)
-
-  const introOutroPath = await downloadInputFile({ url: task.options.file, runnerToken, job })
-
-  try {
-    await buildFFmpegEdition().addIntroOutro({
-      ...pick(options, [ 'inputPath', 'outputPath' ]),
-
-      introOutroPath,
-      type: task.name === 'add-intro'
-        ? 'intro'
-        : 'outro'
-    })
-  } finally {
-    await remove(introOutroPath)
-  }
-}
-
-function processCut (options: TaskProcessorOptions<VideoStudioTaskCutPayload>) {
-  const { inputPath, task } = options
-
-  logger.debug(`Cutting ${inputPath}`)
-
-  return buildFFmpegEdition().cutVideo({
-    ...pick(options, [ 'inputPath', 'outputPath' ]),
-
-    start: task.options.start,
-    end: task.options.end
-  })
-}
-
-async function processAddWatermark (options: TaskProcessorOptions<VideoStudioTaskWatermarkPayload>) {
-  const { inputPath, task, runnerToken, job } = options
-
-  logger.debug('Adding watermark to ' + inputPath)
-
-  const watermarkPath = await downloadInputFile({ url: task.options.file, runnerToken, job })
-
-  try {
-    await buildFFmpegEdition().addWatermark({
-      ...pick(options, [ 'inputPath', 'outputPath' ]),
-
-      watermarkPath,
-
-      videoFilters: {
-        watermarkSizeRatio: task.options.watermarkSizeRatio,
-        horitonzalMarginRatio: task.options.horitonzalMarginRatio,
-        verticalMarginRatio: task.options.verticalMarginRatio
-      }
-    })
-  } finally {
-    await remove(watermarkPath)
-  }
-}
diff --git a/packages/peertube-runner/server/process/shared/process-vod.ts b/packages/peertube-runner/server/process/shared/process-vod.ts
deleted file mode 100644
index f7c076b27..000000000
--- a/packages/peertube-runner/server/process/shared/process-vod.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-import { remove } from 'fs-extra'
-import { logger } from 'packages/peertube-runner/shared'
-import { join } from 'path'
-import { buildUUID } from '@shared/extra-utils'
-import {
-  RunnerJobVODAudioMergeTranscodingPayload,
-  RunnerJobVODHLSTranscodingPayload,
-  RunnerJobVODWebVideoTranscodingPayload,
-  VODAudioMergeTranscodingSuccess,
-  VODHLSTranscodingSuccess,
-  VODWebVideoTranscodingSuccess
-} from '@shared/models'
-import { ConfigManager } from '../../../shared/config-manager'
-import { buildFFmpegVOD, downloadInputFile, ProcessOptions, scheduleTranscodingProgress } from './common'
-
-export async function processWebVideoTranscoding (options: ProcessOptions<RunnerJobVODWebVideoTranscodingPayload>) {
-  const { server, job, runnerToken } = options
-
-  const payload = job.payload
-
-  let ffmpegProgress: number
-  let inputPath: string
-
-  const outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), `output-${buildUUID()}.mp4`)
-
-  const updateProgressInterval = scheduleTranscodingProgress({
-    job,
-    server,
-    runnerToken,
-    progressGetter: () => ffmpegProgress
-  })
-
-  try {
-    logger.info(`Downloading input file ${payload.input.videoFileUrl} for web video transcoding job ${job.jobToken}`)
-
-    inputPath = await downloadInputFile({ url: payload.input.videoFileUrl, runnerToken, job })
-
-    logger.info(`Downloaded input file ${payload.input.videoFileUrl} for job ${job.jobToken}. Running web video transcoding.`)
-
-    const ffmpegVod = buildFFmpegVOD({
-      onJobProgress: progress => { ffmpegProgress = progress }
-    })
-
-    await ffmpegVod.transcode({
-      type: 'video',
-
-      inputPath,
-
-      outputPath,
-
-      inputFileMutexReleaser: () => {},
-
-      resolution: payload.output.resolution,
-      fps: payload.output.fps
-    })
-
-    const successBody: VODWebVideoTranscodingSuccess = {
-      videoFile: outputPath
-    }
-
-    await server.runnerJobs.success({
-      jobToken: job.jobToken,
-      jobUUID: job.uuid,
-      runnerToken,
-      payload: successBody
-    })
-  } finally {
-    if (inputPath) await remove(inputPath)
-    if (outputPath) await remove(outputPath)
-    if (updateProgressInterval) clearInterval(updateProgressInterval)
-  }
-}
-
-export async function processHLSTranscoding (options: ProcessOptions<RunnerJobVODHLSTranscodingPayload>) {
-  const { server, job, runnerToken } = options
-  const payload = job.payload
-
-  let ffmpegProgress: number
-  let inputPath: string
-
-  const uuid = buildUUID()
-  const outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), `${uuid}-${payload.output.resolution}.m3u8`)
-  const videoFilename = `${uuid}-${payload.output.resolution}-fragmented.mp4`
-  const videoPath = join(join(ConfigManager.Instance.getTranscodingDirectory(), videoFilename))
-
-  const updateProgressInterval = scheduleTranscodingProgress({
-    job,
-    server,
-    runnerToken,
-    progressGetter: () => ffmpegProgress
-  })
-
-  try {
-    logger.info(`Downloading input file ${payload.input.videoFileUrl} for HLS transcoding job ${job.jobToken}`)
-
-    inputPath = await downloadInputFile({ url: payload.input.videoFileUrl, runnerToken, job })
-
-    logger.info(`Downloaded input file ${payload.input.videoFileUrl} for job ${job.jobToken}. Running HLS transcoding.`)
-
-    const ffmpegVod = buildFFmpegVOD({
-      onJobProgress: progress => { ffmpegProgress = progress }
-    })
-
-    await ffmpegVod.transcode({
-      type: 'hls',
-      copyCodecs: false,
-      inputPath,
-      hlsPlaylist: { videoFilename },
-      outputPath,
-
-      inputFileMutexReleaser: () => {},
-
-      resolution: payload.output.resolution,
-      fps: payload.output.fps
-    })
-
-    const successBody: VODHLSTranscodingSuccess = {
-      resolutionPlaylistFile: outputPath,
-      videoFile: videoPath
-    }
-
-    await server.runnerJobs.success({
-      jobToken: job.jobToken,
-      jobUUID: job.uuid,
-      runnerToken,
-      payload: successBody
-    })
-  } finally {
-    if (inputPath) await remove(inputPath)
-    if (outputPath) await remove(outputPath)
-    if (videoPath) await remove(videoPath)
-    if (updateProgressInterval) clearInterval(updateProgressInterval)
-  }
-}
-
-export async function processAudioMergeTranscoding (options: ProcessOptions<RunnerJobVODAudioMergeTranscodingPayload>) {
-  const { server, job, runnerToken } = options
-  const payload = job.payload
-
-  let ffmpegProgress: number
-  let audioPath: string
-  let inputPath: string
-
-  const outputPath = join(ConfigManager.Instance.getTranscodingDirectory(), `output-${buildUUID()}.mp4`)
-
-  const updateProgressInterval = scheduleTranscodingProgress({
-    job,
-    server,
-    runnerToken,
-    progressGetter: () => ffmpegProgress
-  })
-
-  try {
-    logger.info(
-      `Downloading input files ${payload.input.audioFileUrl} and ${payload.input.previewFileUrl} ` +
-      `for audio merge transcoding job ${job.jobToken}`
-    )
-
-    audioPath = await downloadInputFile({ url: payload.input.audioFileUrl, runnerToken, job })
-    inputPath = await downloadInputFile({ url: payload.input.previewFileUrl, runnerToken, job })
-
-    logger.info(
-      `Downloaded input files ${payload.input.audioFileUrl} and ${payload.input.previewFileUrl} ` +
-      `for job ${job.jobToken}. Running audio merge transcoding.`
-    )
-
-    const ffmpegVod = buildFFmpegVOD({
-      onJobProgress: progress => { ffmpegProgress = progress }
-    })
-
-    await ffmpegVod.transcode({
-      type: 'merge-audio',
-
-      audioPath,
-      inputPath,
-
-      outputPath,
-
-      inputFileMutexReleaser: () => {},
-
-      resolution: payload.output.resolution,
-      fps: payload.output.fps
-    })
-
-    const successBody: VODAudioMergeTranscodingSuccess = {
-      videoFile: outputPath
-    }
-
-    await server.runnerJobs.success({
-      jobToken: job.jobToken,
-      jobUUID: job.uuid,
-      runnerToken,
-      payload: successBody
-    })
-  } finally {
-    if (audioPath) await remove(audioPath)
-    if (inputPath) await remove(inputPath)
-    if (outputPath) await remove(outputPath)
-    if (updateProgressInterval) clearInterval(updateProgressInterval)
-  }
-}
diff --git a/packages/peertube-runner/server/process/shared/transcoding-logger.ts b/packages/peertube-runner/server/process/shared/transcoding-logger.ts
deleted file mode 100644
index d0f928914..000000000
--- a/packages/peertube-runner/server/process/shared/transcoding-logger.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { logger } from 'packages/peertube-runner/shared/logger'
-
-export function getTranscodingLogger () {
-  return {
-    info: logger.info.bind(logger),
-    debug: logger.debug.bind(logger),
-    warn: logger.warn.bind(logger),
-    error: logger.error.bind(logger)
-  }
-}