4 files changed, 582 insertions, 0 deletions

diff --git a/server/tests/peertube-runner/client-cli.ts b/server/tests/peertube-runner/client-cli.ts
new file mode 100644
index 000000000..90bf73ef7
--- /dev/null
+++ b/server/tests/peertube-runner/client-cli.ts
@@ -0,0 +1,71 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { PeerTubeRunnerProcess } from '@server/tests/shared'
+import { cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers, setDefaultVideoChannel } from '@shared/server-commands'
+
+describe('Test peertube-runner program client CLI', function () {
+  let server: PeerTubeServer
+  let peertubeRunner: PeerTubeRunnerProcess
+
+  before(async function () {
+    this.timeout(120_000)
+
+    server = await createSingleServer(1)
+
+    await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
+
+    await server.config.enableRemoteTranscoding()
+
+    peertubeRunner = new PeerTubeRunnerProcess()
+    await peertubeRunner.runServer()
+  })
+
+  it('Should not have PeerTube instance listed', async function () {
+    const data = await peertubeRunner.listRegisteredPeerTubeInstances()
+
+    expect(data).to.not.contain(server.url)
+  })
+
+  it('Should register a new PeerTube instance', async function () {
+    const registrationToken = await server.runnerRegistrationTokens.getFirstRegistrationToken()
+
+    await peertubeRunner.registerPeerTubeInstance({
+      server,
+      registrationToken,
+      runnerName: 'my super runner',
+      runnerDescription: 'super description'
+    })
+  })
+
+  it('Should list this new PeerTube instance', async function () {
+    const data = await peertubeRunner.listRegisteredPeerTubeInstances()
+
+    expect(data).to.contain(server.url)
+    expect(data).to.contain('my super runner')
+    expect(data).to.contain('super description')
+  })
+
+  it('Should still have the configuration after a restart', async function () {
+    peertubeRunner.kill()
+
+    await peertubeRunner.runServer()
+  })
+
+  it('Should unregister the PeerTube instance', async function () {
+    await peertubeRunner.unregisterPeerTubeInstance({ server })
+  })
+
+  it('Should not have PeerTube instance listed', async function () {
+    const data = await peertubeRunner.listRegisteredPeerTubeInstances()
+
+    expect(data).to.not.contain(server.url)
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+
+    peertubeRunner.kill()
+  })
+})
diff --git a/server/tests/peertube-runner/index.ts b/server/tests/peertube-runner/index.ts
new file mode 100644
index 000000000..6258d6eb2
--- /dev/null
+++ b/server/tests/peertube-runner/index.ts
@@ -0,0 +1,3 @@
+export * from './client-cli'
+export * from './live-transcoding'
+export * from './vod-transcoding'
diff --git a/server/tests/peertube-runner/live-transcoding.ts b/server/tests/peertube-runner/live-transcoding.ts
new file mode 100644
index 000000000..f58e920ba
--- /dev/null
+++ b/server/tests/peertube-runner/live-transcoding.ts
@@ -0,0 +1,178 @@
+import { expect } from 'chai'
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expectStartWith, PeerTubeRunnerProcess, SQLCommand, testLiveVideoResolutions } from '@server/tests/shared'
+import { areMockObjectStorageTestsDisabled, wait } from '@shared/core-utils'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  findExternalSavedVideo,
+  makeRawRequest,
+  ObjectStorageCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  waitJobs,
+  waitUntilLivePublishedOnAllServers,
+  waitUntilLiveWaitingOnAllServers
+} from '@shared/server-commands'
+
+describe('Test Live transcoding in peertube-runner program', function () {
+  let servers: PeerTubeServer[] = []
+  let peertubeRunner: PeerTubeRunnerProcess
+  let sqlCommandServer1: SQLCommand
+
+  function runSuite (options: {
+    objectStorage: boolean
+  }) {
+    const { objectStorage } = options
+
+    it('Should enable transcoding without additional resolutions', async function () {
+      this.timeout(120000)
+
+      const { video } = await servers[0].live.quickCreate({ permanentLive: true, saveReplay: false, privacy: VideoPrivacy.PUBLIC })
+
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: video.uuid })
+      await waitUntilLivePublishedOnAllServers(servers, video.uuid)
+      await waitJobs(servers)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId: video.uuid,
+        resolutions: [ 720, 480, 360, 240, 144 ],
+        objectStorage,
+        transcoded: true
+      })
+
+      await stopFfmpeg(ffmpegCommand)
+
+      await waitUntilLiveWaitingOnAllServers(servers, video.uuid)
+      await servers[0].videos.remove({ id: video.id })
+    })
+
+    it('Should transcode audio only RTMP stream', async function () {
+      this.timeout(120000)
+
+      const { video } = await servers[0].live.quickCreate({ permanentLive: true, saveReplay: false, privacy: VideoPrivacy.UNLISTED })
+
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: video.uuid, fixtureName: 'video_short_no_audio.mp4' })
+      await waitUntilLivePublishedOnAllServers(servers, video.uuid)
+      await waitJobs(servers)
+
+      await stopFfmpeg(ffmpegCommand)
+
+      await waitUntilLiveWaitingOnAllServers(servers, video.uuid)
+      await servers[0].videos.remove({ id: video.id })
+    })
+
+    it('Should save a replay', async function () {
+      this.timeout(120000)
+
+      const { video } = await servers[0].live.quickCreate({ permanentLive: true, saveReplay: true })
+
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: video.uuid })
+      await waitUntilLivePublishedOnAllServers(servers, video.uuid)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId: video.uuid,
+        resolutions: [ 720, 480, 360, 240, 144 ],
+        objectStorage,
+        transcoded: true
+      })
+
+      await stopFfmpeg(ffmpegCommand)
+
+      await waitUntilLiveWaitingOnAllServers(servers, video.uuid)
+      await waitJobs(servers)
+
+      const session = await servers[0].live.findLatestSession({ videoId: video.uuid })
+      expect(session.endingProcessed).to.be.true
+      expect(session.endDate).to.exist
+      expect(session.saveReplay).to.be.true
+
+      const videoLiveDetails = await servers[0].videos.get({ id: video.uuid })
+      const replay = await findExternalSavedVideo(servers[0], videoLiveDetails)
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: replay.uuid })
+
+        expect(video.files).to.have.lengthOf(0)
+        expect(video.streamingPlaylists).to.have.lengthOf(1)
+
+        const files = video.streamingPlaylists[0].files
+        expect(files).to.have.lengthOf(5)
+
+        for (const file of files) {
+          if (objectStorage) {
+            expectStartWith(file.fileUrl, ObjectStorageCommand.getMockPlaylistBaseUrl())
+          }
+
+          await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
+        }
+      }
+    })
+  }
+
+  before(async function () {
+    this.timeout(120_000)
+
+    servers = await createMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    sqlCommandServer1 = new SQLCommand(servers[0])
+
+    await servers[0].config.enableRemoteTranscoding()
+    await servers[0].config.enableTranscoding(true, true, true)
+    await servers[0].config.enableLive({ allowReplay: true, resolutions: 'max', transcoding: true })
+
+    const registrationToken = await servers[0].runnerRegistrationTokens.getFirstRegistrationToken()
+
+    peertubeRunner = new PeerTubeRunnerProcess()
+    await peertubeRunner.runServer({ hideLogs: false })
+    await peertubeRunner.registerPeerTubeInstance({ server: servers[0], registrationToken, runnerName: 'runner' })
+  })
+
+  describe('With lives on local filesystem storage', function () {
+
+    before(async function () {
+      await servers[0].config.enableTranscoding(true, false, true)
+    })
+
+    runSuite({ objectStorage: false })
+  })
+
+  describe('With lives on object storage', function () {
+    if (areMockObjectStorageTestsDisabled()) return
+
+    before(async function () {
+      await ObjectStorageCommand.prepareDefaultMockBuckets()
+
+      await servers[0].kill()
+
+      await servers[0].run(ObjectStorageCommand.getDefaultMockConfig())
+
+      // Wait for peertube runner socket reconnection
+      await wait(1500)
+    })
+
+    runSuite({ objectStorage: true })
+  })
+
+  after(async function () {
+    await peertubeRunner.unregisterPeerTubeInstance({ server: servers[0] })
+    peertubeRunner.kill()
+
+    await cleanupTests(servers)
+  })
+})
diff --git a/server/tests/peertube-runner/vod-transcoding.ts b/server/tests/peertube-runner/vod-transcoding.ts
new file mode 100644
index 000000000..bdf798379
--- /dev/null
+++ b/server/tests/peertube-runner/vod-transcoding.ts
@@ -0,0 +1,330 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+import { expect } from 'chai'
+import { completeCheckHlsPlaylist, completeWebVideoFilesCheck, PeerTubeRunnerProcess } from '@server/tests/shared'
+import { areMockObjectStorageTestsDisabled, getAllFiles, wait } from '@shared/core-utils'
+import { VideoPrivacy } from '@shared/models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  ObjectStorageCommand,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  waitJobs
+} from '@shared/server-commands'
+
+describe('Test VOD transcoding in peertube-runner program', function () {
+  let servers: PeerTubeServer[] = []
+  let peertubeRunner: PeerTubeRunnerProcess
+
+  function runSuite (options: {
+    webtorrentEnabled: boolean
+    hlsEnabled: boolean
+    objectStorage: boolean
+  }) {
+    const { webtorrentEnabled, hlsEnabled, objectStorage } = options
+
+    const objectStorageBaseUrlWebTorrent = objectStorage
+      ? ObjectStorageCommand.getMockWebTorrentBaseUrl()
+      : undefined
+
+    const objectStorageBaseUrlHLS = objectStorage
+      ? ObjectStorageCommand.getMockPlaylistBaseUrl()
+      : undefined
+
+    it('Should upload a classic video mp4 and transcode it', async function () {
+      this.timeout(120000)
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'mp4', fixture: 'video_short.mp4' })
+
+      await waitJobs(servers, { runnerJobs: true })
+
+      for (const server of servers) {
+        if (webtorrentEnabled) {
+          await completeWebVideoFilesCheck({
+            server,
+            originServer: servers[0],
+            fixture: 'video_short.mp4',
+            videoUUID: uuid,
+            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            files: [
+              { resolution: 0 },
+              { resolution: 144 },
+              { resolution: 240 },
+              { resolution: 360 },
+              { resolution: 480 },
+              { resolution: 720 }
+            ]
+          })
+        }
+
+        if (hlsEnabled) {
+          await completeCheckHlsPlaylist({
+            hlsOnly: !webtorrentEnabled,
+            servers,
+            videoUUID: uuid,
+            objectStorageBaseUrl: objectStorageBaseUrlHLS,
+            resolutions: [ 720, 480, 360, 240, 144, 0 ]
+          })
+        }
+      }
+    })
+
+    it('Should upload a webm video and transcode it', async function () {
+      this.timeout(120000)
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'mp4', fixture: 'video_short.webm' })
+
+      await waitJobs(servers, { runnerJobs: true })
+
+      for (const server of servers) {
+        if (webtorrentEnabled) {
+          await completeWebVideoFilesCheck({
+            server,
+            originServer: servers[0],
+            fixture: 'video_short.webm',
+            videoUUID: uuid,
+            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            files: [
+              { resolution: 0 },
+              { resolution: 144 },
+              { resolution: 240 },
+              { resolution: 360 },
+              { resolution: 480 },
+              { resolution: 720 }
+            ]
+          })
+        }
+
+        if (hlsEnabled) {
+          await completeCheckHlsPlaylist({
+            hlsOnly: !webtorrentEnabled,
+            servers,
+            videoUUID: uuid,
+            objectStorageBaseUrl: objectStorageBaseUrlHLS,
+            resolutions: [ 720, 480, 360, 240, 144, 0 ]
+          })
+        }
+      }
+    })
+
+    it('Should upload an audio only video and transcode it', async function () {
+      this.timeout(120000)
+
+      const attributes = { name: 'audio_without_preview', fixture: 'sample.ogg' }
+      const { uuid } = await servers[0].videos.upload({ attributes, mode: 'resumable' })
+
+      await waitJobs(servers, { runnerJobs: true })
+
+      for (const server of servers) {
+        if (webtorrentEnabled) {
+          await completeWebVideoFilesCheck({
+            server,
+            originServer: servers[0],
+            fixture: 'sample.ogg',
+            videoUUID: uuid,
+            objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+            files: [
+              { resolution: 0 },
+              { resolution: 144 },
+              { resolution: 240 },
+              { resolution: 360 },
+              { resolution: 480 }
+            ]
+          })
+        }
+
+        if (hlsEnabled) {
+          await completeCheckHlsPlaylist({
+            hlsOnly: !webtorrentEnabled,
+            servers,
+            videoUUID: uuid,
+            objectStorageBaseUrl: objectStorageBaseUrlHLS,
+            resolutions: [ 480, 360, 240, 144, 0 ]
+          })
+        }
+      }
+    })
+
+    it('Should upload a private video and transcode it', async function () {
+      this.timeout(120000)
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'mp4', fixture: 'video_short.mp4', privacy: VideoPrivacy.PRIVATE })
+
+      await waitJobs(servers, { runnerJobs: true })
+
+      if (webtorrentEnabled) {
+        await completeWebVideoFilesCheck({
+          server: servers[0],
+          originServer: servers[0],
+          fixture: 'video_short.mp4',
+          videoUUID: uuid,
+          objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+          files: [
+            { resolution: 0 },
+            { resolution: 144 },
+            { resolution: 240 },
+            { resolution: 360 },
+            { resolution: 480 },
+            { resolution: 720 }
+          ]
+        })
+      }
+
+      if (hlsEnabled) {
+        await completeCheckHlsPlaylist({
+          hlsOnly: !webtorrentEnabled,
+          servers: [ servers[0] ],
+          videoUUID: uuid,
+          objectStorageBaseUrl: objectStorageBaseUrlHLS,
+          resolutions: [ 720, 480, 360, 240, 144, 0 ]
+        })
+      }
+    })
+
+    it('Should transcode videos on manual run', async function () {
+      this.timeout(120000)
+
+      await servers[0].config.disableTranscoding()
+
+      const { uuid } = await servers[0].videos.quickUpload({ name: 'manual transcoding', fixture: 'video_short.mp4' })
+      await waitJobs(servers, { runnerJobs: true })
+
+      {
+        const video = await servers[0].videos.get({ id: uuid })
+        expect(getAllFiles(video)).to.have.lengthOf(1)
+      }
+
+      await servers[0].config.enableTranscoding(true, true, true)
+
+      await servers[0].videos.runTranscoding({ transcodingType: 'webtorrent', videoId: uuid })
+      await waitJobs(servers, { runnerJobs: true })
+
+      await completeWebVideoFilesCheck({
+        server: servers[0],
+        originServer: servers[0],
+        fixture: 'video_short.mp4',
+        videoUUID: uuid,
+        objectStorageBaseUrl: objectStorageBaseUrlWebTorrent,
+        files: [
+          { resolution: 0 },
+          { resolution: 144 },
+          { resolution: 240 },
+          { resolution: 360 },
+          { resolution: 480 },
+          { resolution: 720 }
+        ]
+      })
+
+      await servers[0].videos.runTranscoding({ transcodingType: 'hls', videoId: uuid })
+      await waitJobs(servers, { runnerJobs: true })
+
+      await completeCheckHlsPlaylist({
+        hlsOnly: false,
+        servers: [ servers[0] ],
+        videoUUID: uuid,
+        objectStorageBaseUrl: objectStorageBaseUrlHLS,
+        resolutions: [ 720, 480, 360, 240, 144, 0 ]
+      })
+    })
+  }
+
+  before(async function () {
+    this.timeout(120_000)
+
+    servers = await createMultipleServers(2)
+
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await doubleFollow(servers[0], servers[1])
+
+    await servers[0].config.enableRemoteTranscoding()
+
+    const registrationToken = await servers[0].runnerRegistrationTokens.getFirstRegistrationToken()
+
+    peertubeRunner = new PeerTubeRunnerProcess()
+    await peertubeRunner.runServer()
+    await peertubeRunner.registerPeerTubeInstance({ server: servers[0], registrationToken, runnerName: 'runner' })
+  })
+
+  describe('With videos on local filesystem storage', function () {
+
+    describe('Web video only enabled', function () {
+
+      before(async function () {
+        await servers[0].config.enableTranscoding(true, false, true)
+      })
+
+      runSuite({ webtorrentEnabled: true, hlsEnabled: false, objectStorage: false })
+    })
+
+    describe('HLS videos only enabled', function () {
+
+      before(async function () {
+        await servers[0].config.enableTranscoding(false, true, true)
+      })
+
+      runSuite({ webtorrentEnabled: false, hlsEnabled: true, objectStorage: false })
+    })
+
+    describe('Web video & HLS enabled', function () {
+
+      before(async function () {
+        await servers[0].config.enableTranscoding(true, true, true)
+      })
+
+      runSuite({ webtorrentEnabled: true, hlsEnabled: true, objectStorage: false })
+    })
+  })
+
+  describe('With videos on object storage', function () {
+    if (areMockObjectStorageTestsDisabled()) return
+
+    before(async function () {
+      await ObjectStorageCommand.prepareDefaultMockBuckets()
+
+      await servers[0].kill()
+
+      await servers[0].run(ObjectStorageCommand.getDefaultMockConfig())
+
+      // Wait for peertube runner socket reconnection
+      await wait(1500)
+    })
+
+    describe('Web video only enabled', function () {
+
+      before(async function () {
+        await servers[0].config.enableTranscoding(true, false, true)
+      })
+
+      runSuite({ webtorrentEnabled: true, hlsEnabled: false, objectStorage: true })
+    })
+
+    describe('HLS videos only enabled', function () {
+
+      before(async function () {
+        await servers[0].config.enableTranscoding(false, true, true)
+      })
+
+      runSuite({ webtorrentEnabled: false, hlsEnabled: true, objectStorage: true })
+    })
+
+    describe('Web video & HLS enabled', function () {
+
+      before(async function () {
+        await servers[0].config.enableTranscoding(true, true, true)
+      })
+
+      runSuite({ webtorrentEnabled: true, hlsEnabled: true, objectStorage: true })
+    })
+  })
+
+  after(async function () {
+    await peertubeRunner.unregisterPeerTubeInstance({ server: servers[0] })
+    peertubeRunner.kill()
+
+    await cleanupTests(servers)
+  })
+})