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, 2279 insertions, 0 deletions

diff --git a/packages/tests/src/api/live/index.ts b/packages/tests/src/api/live/index.ts
new file mode 100644
index 000000000..e61e6c611
--- /dev/null
+++ b/packages/tests/src/api/live/index.ts
@@ -0,0 +1,7 @@
+import './live-constraints.js'
+import './live-fast-restream.js'
+import './live-socket-messages.js'
+import './live-permanent.js'
+import './live-rtmps.js'
+import './live-save-replay.js'
+import './live.js'
diff --git a/packages/tests/src/api/live/live-constraints.ts b/packages/tests/src/api/live/live-constraints.ts
new file mode 100644
index 000000000..f62994cbd
--- /dev/null
+++ b/packages/tests/src/api/live/live-constraints.ts
@@ -0,0 +1,237 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { LiveVideoError, UserVideoQuota, VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  ConfigCommand,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  waitJobs,
+  waitUntilLiveReplacedByReplayOnAllServers,
+  waitUntilLiveWaitingOnAllServers
+} from '@peertube/peertube-server-commands'
+import { checkLiveCleanup } from '../../shared/live.js'
+
+describe('Test live constraints', function () {
+  let servers: PeerTubeServer[] = []
+  let userId: number
+  let userAccessToken: string
+  let userChannelId: number
+
+  async function createLiveWrapper (options: { replay: boolean, permanent: boolean }) {
+    const { replay, permanent } = options
+
+    const liveAttributes = {
+      name: 'user live',
+      channelId: userChannelId,
+      privacy: VideoPrivacy.PUBLIC,
+      saveReplay: replay,
+      replaySettings: options.replay ? { privacy: VideoPrivacy.PUBLIC } : undefined,
+      permanentLive: permanent
+    }
+
+    const { uuid } = await servers[0].live.create({ token: userAccessToken, fields: liveAttributes })
+    return uuid
+  }
+
+  async function checkSaveReplay (videoId: string, resolutions = [ 720 ]) {
+    for (const server of servers) {
+      const video = await server.videos.get({ id: videoId })
+      expect(video.isLive).to.be.false
+      expect(video.duration).to.be.greaterThan(0)
+    }
+
+    await checkLiveCleanup({ server: servers[0], permanent: false, videoUUID: videoId, savedResolutions: resolutions })
+  }
+
+  function updateQuota (options: { total: number, daily: number }) {
+    return servers[0].users.update({
+      userId,
+      videoQuota: options.total,
+      videoQuotaDaily: options.daily
+    })
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          transcoding: {
+            enabled: false
+          }
+        }
+      }
+    })
+
+    {
+      const res = await servers[0].users.generate('user1')
+      userId = res.userId
+      userChannelId = res.userChannelId
+      userAccessToken = res.token
+
+      await updateQuota({ total: 1, daily: -1 })
+    }
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  it('Should not have size limit if save replay is disabled', async function () {
+    this.timeout(60000)
+
+    const userVideoLiveoId = await createLiveWrapper({ replay: false, permanent: false })
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
+  })
+
+  it('Should have size limit depending on user global quota if save replay is enabled on non permanent live', async function () {
+    this.timeout(60000)
+
+    // Wait for user quota memoize cache invalidation
+    await wait(5000)
+
+    const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
+
+    await waitUntilLiveReplacedByReplayOnAllServers(servers, userVideoLiveoId)
+    await waitJobs(servers)
+
+    await checkSaveReplay(userVideoLiveoId)
+
+    const session = await servers[0].live.getReplaySession({ videoId: userVideoLiveoId })
+    expect(session.error).to.equal(LiveVideoError.QUOTA_EXCEEDED)
+  })
+
+  it('Should have size limit depending on user global quota if save replay is enabled on a permanent live', async function () {
+    this.timeout(60000)
+
+    // Wait for user quota memoize cache invalidation
+    await wait(5000)
+
+    const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: true })
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
+
+    await waitJobs(servers)
+    await waitUntilLiveWaitingOnAllServers(servers, userVideoLiveoId)
+
+    const session = await servers[0].live.findLatestSession({ videoId: userVideoLiveoId })
+    expect(session.error).to.equal(LiveVideoError.QUOTA_EXCEEDED)
+  })
+
+  it('Should have size limit depending on user daily quota if save replay is enabled', async function () {
+    this.timeout(60000)
+
+    // Wait for user quota memoize cache invalidation
+    await wait(5000)
+
+    await updateQuota({ total: -1, daily: 1 })
+
+    const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
+
+    await waitUntilLiveReplacedByReplayOnAllServers(servers, userVideoLiveoId)
+    await waitJobs(servers)
+
+    await checkSaveReplay(userVideoLiveoId)
+
+    const session = await servers[0].live.getReplaySession({ videoId: userVideoLiveoId })
+    expect(session.error).to.equal(LiveVideoError.QUOTA_EXCEEDED)
+  })
+
+  it('Should succeed without quota limit', async function () {
+    this.timeout(60000)
+
+    // Wait for user quota memoize cache invalidation
+    await wait(5000)
+
+    await updateQuota({ total: 10 * 1000 * 1000, daily: -1 })
+
+    const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: false })
+  })
+
+  it('Should have the same quota in admin and as a user', async function () {
+    this.timeout(120000)
+
+    const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
+    const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ token: userAccessToken, videoId: userVideoLiveoId })
+
+    await servers[0].live.waitUntilPublished({ videoId: userVideoLiveoId })
+    // Wait previous live cleanups
+    await wait(3000)
+
+    const baseQuota = await servers[0].users.getMyQuotaUsed({ token: userAccessToken })
+
+    let quotaUser: UserVideoQuota
+
+    do {
+      await wait(500)
+
+      quotaUser = await servers[0].users.getMyQuotaUsed({ token: userAccessToken })
+    } while (quotaUser.videoQuotaUsed <= baseQuota.videoQuotaUsed)
+
+    const { data } = await servers[0].users.list()
+    const quotaAdmin = data.find(u => u.username === 'user1')
+
+    expect(quotaUser.videoQuotaUsed).to.be.above(baseQuota.videoQuotaUsed)
+    expect(quotaUser.videoQuotaUsedDaily).to.be.above(baseQuota.videoQuotaUsedDaily)
+
+    expect(quotaAdmin.videoQuotaUsed).to.be.above(baseQuota.videoQuotaUsed)
+    expect(quotaAdmin.videoQuotaUsedDaily).to.be.above(baseQuota.videoQuotaUsedDaily)
+
+    expect(quotaUser.videoQuotaUsed).to.be.above(10)
+    expect(quotaUser.videoQuotaUsedDaily).to.be.above(10)
+    expect(quotaAdmin.videoQuotaUsed).to.be.above(10)
+    expect(quotaAdmin.videoQuotaUsedDaily).to.be.above(10)
+
+    await stopFfmpeg(ffmpegCommand)
+  })
+
+  it('Should have max duration limit', async function () {
+    this.timeout(240000)
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          maxDuration: 15,
+          transcoding: {
+            enabled: true,
+            resolutions: ConfigCommand.getCustomConfigResolutions(true)
+          }
+        }
+      }
+    })
+
+    const userVideoLiveoId = await createLiveWrapper({ replay: true, permanent: false })
+    await servers[0].live.runAndTestStreamError({ token: userAccessToken, videoId: userVideoLiveoId, shouldHaveError: true })
+
+    await waitUntilLiveReplacedByReplayOnAllServers(servers, userVideoLiveoId)
+    await waitJobs(servers)
+
+    await checkSaveReplay(userVideoLiveoId, [ 720, 480, 360, 240, 144 ])
+
+    const session = await servers[0].live.getReplaySession({ videoId: userVideoLiveoId })
+    expect(session.error).to.equal(LiveVideoError.DURATION_EXCEEDED)
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/live/live-fast-restream.ts b/packages/tests/src/api/live/live-fast-restream.ts
new file mode 100644
index 000000000..d34b00cbe
--- /dev/null
+++ b/packages/tests/src/api/live/live-fast-restream.ts
@@ -0,0 +1,153 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { LiveVideoCreate, VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Fast restream in live', function () {
+  let server: PeerTubeServer
+
+  async function createLiveWrapper (options: { permanent: boolean, replay: boolean }) {
+    const attributes: LiveVideoCreate = {
+      channelId: server.store.channel.id,
+      privacy: VideoPrivacy.PUBLIC,
+      name: 'my super live',
+      saveReplay: options.replay,
+      replaySettings: options.replay ? { privacy: VideoPrivacy.PUBLIC } : undefined,
+      permanentLive: options.permanent
+    }
+
+    const { uuid } = await server.live.create({ fields: attributes })
+    return uuid
+  }
+
+  async function fastRestreamWrapper ({ replay }: { replay: boolean }) {
+    const liveVideoUUID = await createLiveWrapper({ permanent: true, replay })
+    await waitJobs([ server ])
+
+    const rtmpOptions = {
+      videoId: liveVideoUUID,
+      copyCodecs: true,
+      fixtureName: 'video_short.mp4'
+    }
+
+    // Streaming session #1
+    let ffmpegCommand = await server.live.sendRTMPStreamInVideo(rtmpOptions)
+    await server.live.waitUntilPublished({ videoId: liveVideoUUID })
+
+    const video = await server.videos.get({ id: liveVideoUUID })
+    const session1PlaylistId = video.streamingPlaylists[0].id
+
+    await stopFfmpeg(ffmpegCommand)
+    await server.live.waitUntilWaiting({ videoId: liveVideoUUID })
+
+    // Streaming session #2
+    ffmpegCommand = await server.live.sendRTMPStreamInVideo(rtmpOptions)
+
+    let hasNewPlaylist = false
+    do {
+      const video = await server.videos.get({ id: liveVideoUUID })
+      hasNewPlaylist = video.streamingPlaylists.length === 1 && video.streamingPlaylists[0].id !== session1PlaylistId
+
+      await wait(100)
+    } while (!hasNewPlaylist)
+
+    await server.live.waitUntilSegmentGeneration({
+      server,
+      videoUUID: liveVideoUUID,
+      segment: 1,
+      playlistNumber: 0
+    })
+
+    return { ffmpegCommand, liveVideoUUID }
+  }
+
+  async function ensureLastLiveWorks (liveId: string) {
+    // Equivalent to PEERTUBE_TEST_CONSTANTS_VIDEO_LIVE_CLEANUP_DELAY
+    for (let i = 0; i < 100; i++) {
+      const video = await server.videos.get({ id: liveId })
+      expect(video.streamingPlaylists).to.have.lengthOf(1)
+
+      try {
+        await server.live.getSegmentFile({ videoUUID: liveId, segment: 0, playlistNumber: 0 })
+        await server.streamingPlaylists.get({ url: video.streamingPlaylists[0].playlistUrl })
+        await server.streamingPlaylists.getSegmentSha256({ url: video.streamingPlaylists[0].segmentsSha256Url })
+      } catch (err) {
+        // FIXME: try to debug error in CI "Unexpected end of JSON input"
+        console.error(err)
+        throw err
+      }
+
+      await wait(100)
+    }
+  }
+
+  async function runTest (replay: boolean) {
+    const { ffmpegCommand, liveVideoUUID } = await fastRestreamWrapper({ replay })
+
+    // TODO: remove, we try to debug a test timeout failure here
+    console.log('Ensuring last live works')
+
+    await ensureLastLiveWorks(liveVideoUUID)
+
+    await stopFfmpeg(ffmpegCommand)
+    await server.live.waitUntilWaiting({ videoId: liveVideoUUID })
+
+    // Wait for replays
+    await waitJobs([ server ])
+
+    const { total, data: sessions } = await server.live.listSessions({ videoId: liveVideoUUID })
+
+    expect(total).to.equal(2)
+    expect(sessions).to.have.lengthOf(2)
+
+    for (const session of sessions) {
+      expect(session.error).to.be.null
+
+      if (replay) {
+        expect(session.replayVideo).to.exist
+
+        await server.videos.get({ id: session.replayVideo.uuid })
+      } else {
+        expect(session.replayVideo).to.not.exist
+      }
+    }
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    const env = { PEERTUBE_TEST_CONSTANTS_VIDEO_LIVE_CLEANUP_DELAY: '10000' }
+    server = await createSingleServer(1, {}, { env })
+
+    // Get the access tokens
+    await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
+
+    await server.config.enableMinimumTranscoding({ webVideo: false, hls: true })
+    await server.config.enableLive({ allowReplay: true, transcoding: true, resolutions: 'min' })
+  })
+
+  it('Should correctly fast restream in a permanent live with and without save replay', async function () {
+    this.timeout(480000)
+
+    // A test can take a long time, so prefer to run them in parallel
+    await Promise.all([
+      runTest(true),
+      runTest(false)
+    ])
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/live/live-permanent.ts b/packages/tests/src/api/live/live-permanent.ts
new file mode 100644
index 000000000..4ffcc7ed4
--- /dev/null
+++ b/packages/tests/src/api/live/live-permanent.ts
@@ -0,0 +1,204 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { LiveVideoCreate, VideoPrivacy, VideoState, VideoStateType } from '@peertube/peertube-models'
+import { checkLiveCleanup } from '@tests/shared/live.js'
+import {
+  cleanupTests,
+  ConfigCommand,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  waitJobs
+} from '@peertube/peertube-server-commands'
+
+describe('Permanent live', function () {
+  let servers: PeerTubeServer[] = []
+  let videoUUID: string
+
+  async function createLiveWrapper (permanentLive: boolean) {
+    const attributes: LiveVideoCreate = {
+      channelId: servers[0].store.channel.id,
+      privacy: VideoPrivacy.PUBLIC,
+      name: 'my super live',
+      saveReplay: false,
+      permanentLive
+    }
+
+    const { uuid } = await servers[0].live.create({ fields: attributes })
+    return uuid
+  }
+
+  async function checkVideoState (videoId: string, state: VideoStateType) {
+    for (const server of servers) {
+      const video = await server.videos.get({ id: videoId })
+      expect(video.state.id).to.equal(state)
+    }
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          maxDuration: -1,
+          transcoding: {
+            enabled: true,
+            resolutions: ConfigCommand.getCustomConfigResolutions(true)
+          }
+        }
+      }
+    })
+  })
+
+  it('Should create a non permanent live and update it to be a permanent live', async function () {
+    this.timeout(20000)
+
+    const videoUUID = await createLiveWrapper(false)
+
+    {
+      const live = await servers[0].live.get({ videoId: videoUUID })
+      expect(live.permanentLive).to.be.false
+    }
+
+    await servers[0].live.update({ videoId: videoUUID, fields: { permanentLive: true } })
+
+    {
+      const live = await servers[0].live.get({ videoId: videoUUID })
+      expect(live.permanentLive).to.be.true
+    }
+  })
+
+  it('Should create a permanent live', async function () {
+    this.timeout(20000)
+
+    videoUUID = await createLiveWrapper(true)
+
+    const live = await servers[0].live.get({ videoId: videoUUID })
+    expect(live.permanentLive).to.be.true
+
+    await waitJobs(servers)
+  })
+
+  it('Should stream into this permanent live', async function () {
+    this.timeout(240_000)
+
+    const beforePublication = new Date()
+    const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
+
+    for (const server of servers) {
+      await server.live.waitUntilPublished({ videoId: videoUUID })
+    }
+
+    await checkVideoState(videoUUID, VideoState.PUBLISHED)
+
+    for (const server of servers) {
+      const video = await server.videos.get({ id: videoUUID })
+      expect(new Date(video.publishedAt)).greaterThan(beforePublication)
+    }
+
+    await stopFfmpeg(ffmpegCommand)
+    await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
+
+    await waitJobs(servers)
+  })
+
+  it('Should have cleaned up this live', async function () {
+    this.timeout(40000)
+
+    await wait(5000)
+    await waitJobs(servers)
+
+    for (const server of servers) {
+      const videoDetails = await server.videos.get({ id: videoUUID })
+
+      expect(videoDetails.streamingPlaylists).to.have.lengthOf(0)
+    }
+
+    await checkLiveCleanup({ server: servers[0], permanent: true, videoUUID })
+  })
+
+  it('Should have set this live to waiting for live state', async function () {
+    this.timeout(20000)
+
+    await checkVideoState(videoUUID, VideoState.WAITING_FOR_LIVE)
+  })
+
+  it('Should be able to stream again in the permanent live', async function () {
+    this.timeout(60000)
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          maxDuration: -1,
+          transcoding: {
+            enabled: true,
+            resolutions: ConfigCommand.getCustomConfigResolutions(false)
+          }
+        }
+      }
+    })
+
+    const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
+
+    for (const server of servers) {
+      await server.live.waitUntilPublished({ videoId: videoUUID })
+    }
+
+    await checkVideoState(videoUUID, VideoState.PUBLISHED)
+
+    const count = await servers[0].live.countPlaylists({ videoUUID })
+    // master playlist and 720p playlist
+    expect(count).to.equal(2)
+
+    await stopFfmpeg(ffmpegCommand)
+  })
+
+  it('Should have appropriate sessions', async function () {
+    this.timeout(60000)
+
+    await servers[0].live.waitUntilWaiting({ videoId: videoUUID })
+
+    const { data, total } = await servers[0].live.listSessions({ videoId: videoUUID })
+    expect(total).to.equal(2)
+    expect(data).to.have.lengthOf(2)
+
+    for (const session of data) {
+      expect(session.startDate).to.exist
+      expect(session.endDate).to.exist
+
+      expect(session.error).to.not.exist
+    }
+  })
+
+  it('Should remove the live and have cleaned up the directory', async function () {
+    this.timeout(60000)
+
+    await servers[0].videos.remove({ id: videoUUID })
+    await waitJobs(servers)
+
+    await checkLiveCleanup({ server: servers[0], permanent: true, videoUUID })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/live/live-rtmps.ts b/packages/tests/src/api/live/live-rtmps.ts
new file mode 100644
index 000000000..4ab59ed4c
--- /dev/null
+++ b/packages/tests/src/api/live/live-rtmps.ts
@@ -0,0 +1,143 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { buildAbsoluteFixturePath } from '@peertube/peertube-node-utils'
+import { VideoPrivacy } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createSingleServer,
+  PeerTubeServer,
+  sendRTMPStream,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  testFfmpegStreamError,
+  waitUntilLivePublishedOnAllServers
+} from '@peertube/peertube-server-commands'
+
+describe('Test live RTMPS', function () {
+  let server: PeerTubeServer
+  let rtmpUrl: string
+  let rtmpsUrl: string
+
+  async function createLiveWrapper () {
+    const liveAttributes = {
+      name: 'live',
+      channelId: server.store.channel.id,
+      privacy: VideoPrivacy.PUBLIC,
+      saveReplay: false
+    }
+
+    const { uuid } = await server.live.create({ fields: liveAttributes })
+
+    const live = await server.live.get({ videoId: uuid })
+    const video = await server.videos.get({ id: uuid })
+
+    return Object.assign(video, live)
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    server = await createSingleServer(1)
+
+    // Get the access tokens
+    await setAccessTokensToServers([ server ])
+    await setDefaultVideoChannel([ server ])
+
+    await server.config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          transcoding: {
+            enabled: false
+          }
+        }
+      }
+    })
+
+    rtmpUrl = 'rtmp://' + server.hostname + ':' + server.rtmpPort + '/live'
+    rtmpsUrl = 'rtmps://' + server.hostname + ':' + server.rtmpsPort + '/live'
+  })
+
+  it('Should enable RTMPS endpoint only', async function () {
+    this.timeout(240000)
+
+    await server.kill()
+    await server.run({
+      live: {
+        rtmp: {
+          enabled: false
+        },
+        rtmps: {
+          enabled: true,
+          port: server.rtmpsPort,
+          key_file: buildAbsoluteFixturePath('rtmps.key'),
+          cert_file: buildAbsoluteFixturePath('rtmps.cert')
+        }
+      }
+    })
+
+    {
+      const liveVideo = await createLiveWrapper()
+
+      expect(liveVideo.rtmpUrl).to.not.exist
+      expect(liveVideo.rtmpsUrl).to.equal(rtmpsUrl)
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl, streamKey: liveVideo.streamKey })
+      await testFfmpegStreamError(command, true)
+    }
+
+    {
+      const liveVideo = await createLiveWrapper()
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpsUrl, streamKey: liveVideo.streamKey })
+      await waitUntilLivePublishedOnAllServers([ server ], liveVideo.uuid)
+      await stopFfmpeg(command)
+    }
+  })
+
+  it('Should enable both RTMP and RTMPS', async function () {
+    this.timeout(240000)
+
+    await server.kill()
+    await server.run({
+      live: {
+        rtmp: {
+          enabled: true,
+          port: server.rtmpPort
+        },
+        rtmps: {
+          enabled: true,
+          port: server.rtmpsPort,
+          key_file: buildAbsoluteFixturePath('rtmps.key'),
+          cert_file: buildAbsoluteFixturePath('rtmps.cert')
+        }
+      }
+    })
+
+    {
+      const liveVideo = await createLiveWrapper()
+
+      expect(liveVideo.rtmpUrl).to.equal(rtmpUrl)
+      expect(liveVideo.rtmpsUrl).to.equal(rtmpsUrl)
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl, streamKey: liveVideo.streamKey })
+      await waitUntilLivePublishedOnAllServers([ server ], liveVideo.uuid)
+      await stopFfmpeg(command)
+    }
+
+    {
+      const liveVideo = await createLiveWrapper()
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpsUrl, streamKey: liveVideo.streamKey })
+      await waitUntilLivePublishedOnAllServers([ server ], liveVideo.uuid)
+      await stopFfmpeg(command)
+    }
+  })
+
+  after(async function () {
+    await cleanupTests([ server ])
+  })
+})
diff --git a/packages/tests/src/api/live/live-save-replay.ts b/packages/tests/src/api/live/live-save-replay.ts
new file mode 100644
index 000000000..84135365b
--- /dev/null
+++ b/packages/tests/src/api/live/live-save-replay.ts
@@ -0,0 +1,583 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { FfmpegCommand } from 'fluent-ffmpeg'
+import { wait } from '@peertube/peertube-core-utils'
+import {
+  HttpStatusCode,
+  HttpStatusCodeType,
+  LiveVideoCreate,
+  LiveVideoError,
+  VideoPrivacy,
+  VideoPrivacyType,
+  VideoState,
+  VideoStateType
+} from '@peertube/peertube-models'
+import { checkLiveCleanup } from '@tests/shared/live.js'
+import {
+  cleanupTests,
+  ConfigCommand,
+  createMultipleServers,
+  doubleFollow,
+  findExternalSavedVideo,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  testFfmpegStreamError,
+  waitJobs,
+  waitUntilLivePublishedOnAllServers,
+  waitUntilLiveReplacedByReplayOnAllServers,
+  waitUntilLiveWaitingOnAllServers
+} from '@peertube/peertube-server-commands'
+
+describe('Save replay setting', function () {
+  let servers: PeerTubeServer[] = []
+  let liveVideoUUID: string
+  let ffmpegCommand: FfmpegCommand
+
+  async function createLiveWrapper (options: { permanent: boolean, replay: boolean, replaySettings?: { privacy: VideoPrivacyType } }) {
+    if (liveVideoUUID) {
+      try {
+        await servers[0].videos.remove({ id: liveVideoUUID })
+        await waitJobs(servers)
+      } catch {}
+    }
+
+    const attributes: LiveVideoCreate = {
+      channelId: servers[0].store.channel.id,
+      privacy: VideoPrivacy.PUBLIC,
+      name: 'live'.repeat(30),
+      saveReplay: options.replay,
+      replaySettings: options.replaySettings,
+      permanentLive: options.permanent
+    }
+
+    const { uuid } = await servers[0].live.create({ fields: attributes })
+    return uuid
+  }
+
+  async function publishLive (options: { permanent: boolean, replay: boolean, replaySettings?: { privacy: VideoPrivacyType } }) {
+    liveVideoUUID = await createLiveWrapper(options)
+
+    const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+    await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+
+    const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
+
+    await waitJobs(servers)
+    await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+
+    return { ffmpegCommand, liveDetails }
+  }
+
+  async function publishLiveAndDelete (options: { permanent: boolean, replay: boolean, replaySettings?: { privacy: VideoPrivacyType } }) {
+    const { ffmpegCommand, liveDetails } = await publishLive(options)
+
+    await Promise.all([
+      servers[0].videos.remove({ id: liveVideoUUID }),
+      testFfmpegStreamError(ffmpegCommand, true)
+    ])
+
+    await waitJobs(servers)
+    await wait(5000)
+    await waitJobs(servers)
+
+    return { liveDetails }
+  }
+
+  async function publishLiveAndBlacklist (options: {
+    permanent: boolean
+    replay: boolean
+    replaySettings?: { privacy: VideoPrivacyType }
+  }) {
+    const { ffmpegCommand, liveDetails } = await publishLive(options)
+
+    await Promise.all([
+      servers[0].blacklist.add({ videoId: liveVideoUUID, reason: 'bad live', unfederate: true }),
+      testFfmpegStreamError(ffmpegCommand, true)
+    ])
+
+    await waitJobs(servers)
+    await wait(5000)
+    await waitJobs(servers)
+
+    return { liveDetails }
+  }
+
+  async function checkVideosExist (videoId: string, existsInList: boolean, expectedStatus?: HttpStatusCodeType) {
+    for (const server of servers) {
+      const length = existsInList ? 1 : 0
+
+      const { data, total } = await server.videos.list()
+      expect(data).to.have.lengthOf(length)
+      expect(total).to.equal(length)
+
+      if (expectedStatus) {
+        await server.videos.get({ id: videoId, expectedStatus })
+      }
+    }
+  }
+
+  async function checkVideoState (videoId: string, state: VideoStateType) {
+    for (const server of servers) {
+      const video = await server.videos.get({ id: videoId })
+      expect(video.state.id).to.equal(state)
+    }
+  }
+
+  async function checkVideoPrivacy (videoId: string, privacy: VideoPrivacyType) {
+    for (const server of servers) {
+      const video = await server.videos.get({ id: videoId })
+      expect(video.privacy.id).to.equal(privacy)
+    }
+  }
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          maxDuration: -1,
+          transcoding: {
+            enabled: false,
+            resolutions: ConfigCommand.getCustomConfigResolutions(true)
+          }
+        }
+      }
+    })
+  })
+
+  describe('With save replay disabled', function () {
+    let sessionStartDateMin: Date
+    let sessionStartDateMax: Date
+    let sessionEndDateMin: Date
+
+    it('Should correctly create and federate the "waiting for stream" live', async function () {
+      this.timeout(40000)
+
+      liveVideoUUID = await createLiveWrapper({ permanent: false, replay: false })
+
+      await waitJobs(servers)
+
+      await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
+      await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
+    })
+
+    it('Should correctly have updated the live and federated it when streaming in the live', async function () {
+      this.timeout(120000)
+
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+
+      sessionStartDateMin = new Date()
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+      sessionStartDateMax = new Date()
+
+      await waitJobs(servers)
+
+      await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+      await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+    })
+
+    it('Should correctly delete the video files after the stream ended', async function () {
+      this.timeout(120000)
+
+      sessionEndDateMin = new Date()
+      await stopFfmpeg(ffmpegCommand)
+
+      for (const server of servers) {
+        await server.live.waitUntilEnded({ videoId: liveVideoUUID })
+      }
+      await waitJobs(servers)
+
+      // Live still exist, but cannot be played anymore
+      await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
+      await checkVideoState(liveVideoUUID, VideoState.LIVE_ENDED)
+
+      // No resolutions saved since we did not save replay
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+    })
+
+    it('Should have appropriate ended session', async function () {
+      const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
+
+      const session = data[0]
+
+      const startDate = new Date(session.startDate)
+      expect(startDate).to.be.above(sessionStartDateMin)
+      expect(startDate).to.be.below(sessionStartDateMax)
+
+      expect(session.endDate).to.exist
+      expect(new Date(session.endDate)).to.be.above(sessionEndDateMin)
+
+      expect(session.saveReplay).to.be.false
+      expect(session.error).to.not.exist
+      expect(session.replayVideo).to.not.exist
+    })
+
+    it('Should correctly terminate the stream on blacklist and delete the live', async function () {
+      this.timeout(120000)
+
+      await publishLiveAndBlacklist({ permanent: false, replay: false })
+
+      await checkVideosExist(liveVideoUUID, false)
+
+      await servers[0].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await servers[1].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+
+      await wait(5000)
+      await waitJobs(servers)
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+    })
+
+    it('Should have blacklisted session error', async function () {
+      const session = await servers[0].live.findLatestSession({ videoId: liveVideoUUID })
+      expect(session.startDate).to.exist
+      expect(session.endDate).to.exist
+
+      expect(session.error).to.equal(LiveVideoError.BLACKLISTED)
+      expect(session.replayVideo).to.not.exist
+    })
+
+    it('Should correctly terminate the stream on delete and delete the video', async function () {
+      this.timeout(120000)
+
+      await publishLiveAndDelete({ permanent: false, replay: false })
+
+      await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+    })
+  })
+
+  describe('With save replay enabled on non permanent live', function () {
+
+    it('Should correctly create and federate the "waiting for stream" live', async function () {
+      this.timeout(120000)
+
+      liveVideoUUID = await createLiveWrapper({ permanent: false, replay: true, replaySettings: { privacy: VideoPrivacy.UNLISTED } })
+
+      await waitJobs(servers)
+
+      await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
+      await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
+      await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+    })
+
+    it('Should correctly have updated the live and federated it when streaming in the live', async function () {
+      this.timeout(120000)
+
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+
+      await waitJobs(servers)
+
+      await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+      await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+      await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+    })
+
+    it('Should correctly have saved the live and federated it after the streaming', async function () {
+      this.timeout(120000)
+
+      const session = await servers[0].live.findLatestSession({ videoId: liveVideoUUID })
+      expect(session.endDate).to.not.exist
+      expect(session.endingProcessed).to.be.false
+      expect(session.saveReplay).to.be.true
+      expect(session.replaySettings).to.exist
+      expect(session.replaySettings.privacy).to.equal(VideoPrivacy.UNLISTED)
+
+      await stopFfmpeg(ffmpegCommand)
+
+      await waitUntilLiveReplacedByReplayOnAllServers(servers, liveVideoUUID)
+      await waitJobs(servers)
+
+      // Live has been transcoded
+      await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
+      await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+      await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.UNLISTED)
+    })
+
+    it('Should find the replay live session', async function () {
+      const session = await servers[0].live.getReplaySession({ videoId: liveVideoUUID })
+
+      expect(session).to.exist
+
+      expect(session.startDate).to.exist
+      expect(session.endDate).to.exist
+
+      expect(session.error).to.not.exist
+      expect(session.saveReplay).to.be.true
+      expect(session.endingProcessed).to.be.true
+      expect(session.replaySettings).to.exist
+      expect(session.replaySettings.privacy).to.equal(VideoPrivacy.UNLISTED)
+
+      expect(session.replayVideo).to.exist
+      expect(session.replayVideo.id).to.exist
+      expect(session.replayVideo.shortUUID).to.exist
+      expect(session.replayVideo.uuid).to.equal(liveVideoUUID)
+    })
+
+    it('Should update the saved live and correctly federate the updated attributes', async function () {
+      this.timeout(120000)
+
+      await servers[0].videos.update({ id: liveVideoUUID, attributes: { name: 'video updated', privacy: VideoPrivacy.PUBLIC } })
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: liveVideoUUID })
+        expect(video.name).to.equal('video updated')
+        expect(video.isLive).to.be.false
+        expect(video.privacy.id).to.equal(VideoPrivacy.PUBLIC)
+      }
+    })
+
+    it('Should have cleaned up the live files', async function () {
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false, savedResolutions: [ 720 ] })
+    })
+
+    it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
+      this.timeout(120000)
+
+      await publishLiveAndBlacklist({ permanent: false, replay: true, replaySettings: { privacy: VideoPrivacy.PUBLIC } })
+
+      await checkVideosExist(liveVideoUUID, false)
+
+      await servers[0].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+      await servers[1].videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+
+      await wait(5000)
+      await waitJobs(servers)
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false, savedResolutions: [ 720 ] })
+    })
+
+    it('Should correctly terminate the stream on delete and delete the video', async function () {
+      this.timeout(120000)
+
+      await publishLiveAndDelete({ permanent: false, replay: true, replaySettings: { privacy: VideoPrivacy.PUBLIC } })
+
+      await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
+      await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+    })
+  })
+
+  describe('With save replay enabled on permanent live', function () {
+    let lastReplayUUID: string
+
+    describe('With a first live and its replay', function () {
+
+      it('Should correctly create and federate the "waiting for stream" live', async function () {
+        this.timeout(120000)
+
+        liveVideoUUID = await createLiveWrapper({ permanent: true, replay: true, replaySettings: { privacy: VideoPrivacy.UNLISTED } })
+
+        await waitJobs(servers)
+
+        await checkVideosExist(liveVideoUUID, false, HttpStatusCode.OK_200)
+        await checkVideoState(liveVideoUUID, VideoState.WAITING_FOR_LIVE)
+        await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+      })
+
+      it('Should correctly have updated the live and federated it when streaming in the live', async function () {
+        this.timeout(120000)
+
+        ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+        await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+
+        await waitJobs(servers)
+
+        await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+        await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+        await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+      })
+
+      it('Should correctly have saved the live and federated it after the streaming', async function () {
+        this.timeout(120000)
+
+        const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
+
+        await stopFfmpeg(ffmpegCommand)
+
+        await waitUntilLiveWaitingOnAllServers(servers, liveVideoUUID)
+        await waitJobs(servers)
+
+        const video = await findExternalSavedVideo(servers[0], liveDetails)
+        expect(video).to.exist
+
+        for (const server of servers) {
+          await server.videos.get({ id: video.uuid })
+        }
+
+        lastReplayUUID = video.uuid
+      })
+
+      it('Should have appropriate ended session and replay live session', async function () {
+        const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+
+        const sessionFromLive = data[0]
+        const sessionFromReplay = await servers[0].live.getReplaySession({ videoId: lastReplayUUID })
+
+        for (const session of [ sessionFromLive, sessionFromReplay ]) {
+          expect(session.startDate).to.exist
+          expect(session.endDate).to.exist
+
+          expect(session.replaySettings).to.exist
+          expect(session.replaySettings.privacy).to.equal(VideoPrivacy.UNLISTED)
+
+          expect(session.error).to.not.exist
+
+          expect(session.replayVideo).to.exist
+          expect(session.replayVideo.id).to.exist
+          expect(session.replayVideo.shortUUID).to.exist
+          expect(session.replayVideo.uuid).to.equal(lastReplayUUID)
+        }
+      })
+
+      it('Should have the first live replay with correct settings', async function () {
+        await checkVideosExist(lastReplayUUID, false, HttpStatusCode.OK_200)
+        await checkVideoState(lastReplayUUID, VideoState.PUBLISHED)
+        await checkVideoPrivacy(lastReplayUUID, VideoPrivacy.UNLISTED)
+      })
+    })
+
+    describe('With a second live and its replay', function () {
+
+      it('Should update the replay settings', async function () {
+        await servers[0].live.update({ videoId: liveVideoUUID, fields: { replaySettings: { privacy: VideoPrivacy.PUBLIC } } })
+        await waitJobs(servers)
+
+        const live = await servers[0].live.get({ videoId: liveVideoUUID })
+
+        expect(live.saveReplay).to.be.true
+        expect(live.replaySettings).to.exist
+        expect(live.replaySettings.privacy).to.equal(VideoPrivacy.PUBLIC)
+
+      })
+
+      it('Should correctly have updated the live and federated it when streaming in the live', async function () {
+        this.timeout(120000)
+
+        ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+        await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+
+        await waitJobs(servers)
+
+        await checkVideosExist(liveVideoUUID, true, HttpStatusCode.OK_200)
+        await checkVideoState(liveVideoUUID, VideoState.PUBLISHED)
+        await checkVideoPrivacy(liveVideoUUID, VideoPrivacy.PUBLIC)
+      })
+
+      it('Should correctly have saved the live and federated it after the streaming', async function () {
+        this.timeout(120000)
+
+        const liveDetails = await servers[0].videos.get({ id: liveVideoUUID })
+
+        await stopFfmpeg(ffmpegCommand)
+
+        await waitUntilLiveWaitingOnAllServers(servers, liveVideoUUID)
+        await waitJobs(servers)
+
+        const video = await findExternalSavedVideo(servers[0], liveDetails)
+        expect(video).to.exist
+
+        for (const server of servers) {
+          await server.videos.get({ id: video.uuid })
+        }
+
+        lastReplayUUID = video.uuid
+      })
+
+      it('Should have appropriate ended session and replay live session', async function () {
+        const { data, total } = await servers[0].live.listSessions({ videoId: liveVideoUUID })
+        expect(total).to.equal(2)
+        expect(data).to.have.lengthOf(2)
+
+        const sessionFromLive = data[1]
+        const sessionFromReplay = await servers[0].live.getReplaySession({ videoId: lastReplayUUID })
+
+        for (const session of [ sessionFromLive, sessionFromReplay ]) {
+          expect(session.startDate).to.exist
+          expect(session.endDate).to.exist
+
+          expect(session.replaySettings).to.exist
+          expect(session.replaySettings.privacy).to.equal(VideoPrivacy.PUBLIC)
+
+          expect(session.error).to.not.exist
+
+          expect(session.replayVideo).to.exist
+          expect(session.replayVideo.id).to.exist
+          expect(session.replayVideo.shortUUID).to.exist
+          expect(session.replayVideo.uuid).to.equal(lastReplayUUID)
+        }
+      })
+
+      it('Should have the first live replay with correct settings', async function () {
+        await checkVideosExist(lastReplayUUID, true, HttpStatusCode.OK_200)
+        await checkVideoState(lastReplayUUID, VideoState.PUBLISHED)
+        await checkVideoPrivacy(lastReplayUUID, VideoPrivacy.PUBLIC)
+      })
+
+      it('Should have cleaned up the live files', async function () {
+        await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+      })
+
+      it('Should correctly terminate the stream on blacklist and blacklist the saved replay video', async function () {
+        this.timeout(120000)
+
+        await servers[0].videos.remove({ id: lastReplayUUID })
+        const { liveDetails } = await publishLiveAndBlacklist({
+          permanent: true,
+          replay: true,
+          replaySettings: { privacy: VideoPrivacy.PUBLIC }
+        })
+
+        const replay = await findExternalSavedVideo(servers[0], liveDetails)
+        expect(replay).to.exist
+
+        for (const videoId of [ liveVideoUUID, replay.uuid ]) {
+          await checkVideosExist(videoId, false)
+
+          await servers[0].videos.get({ id: videoId, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+          await servers[1].videos.get({ id: videoId, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+        }
+
+        await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+      })
+
+      it('Should correctly terminate the stream on delete and not save the video', async function () {
+        this.timeout(120000)
+
+        const { liveDetails } = await publishLiveAndDelete({
+          permanent: true,
+          replay: true,
+          replaySettings: { privacy: VideoPrivacy.PUBLIC }
+        })
+
+        const replay = await findExternalSavedVideo(servers[0], liveDetails)
+        expect(replay).to.not.exist
+
+        await checkVideosExist(liveVideoUUID, false, HttpStatusCode.NOT_FOUND_404)
+        await checkLiveCleanup({ server: servers[0], videoUUID: liveVideoUUID, permanent: false })
+      })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/live/live-socket-messages.ts b/packages/tests/src/api/live/live-socket-messages.ts
new file mode 100644
index 000000000..80bae154c
--- /dev/null
+++ b/packages/tests/src/api/live/live-socket-messages.ts
@@ -0,0 +1,186 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { wait } from '@peertube/peertube-core-utils'
+import { LiveVideoEventPayload, VideoPrivacy, VideoState, VideoStateType } from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  waitJobs,
+  waitUntilLivePublishedOnAllServers
+} from '@peertube/peertube-server-commands'
+
+describe('Test live socket messages', function () {
+  let servers: PeerTubeServer[] = []
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          transcoding: {
+            enabled: false
+          }
+        }
+      }
+    })
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('Live socket messages', function () {
+
+    async function createLiveWrapper () {
+      const liveAttributes = {
+        name: 'live video',
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC
+      }
+
+      const { uuid } = await servers[0].live.create({ fields: liveAttributes })
+      return uuid
+    }
+
+    it('Should correctly send a message when the live starts and ends', async function () {
+      this.timeout(60000)
+
+      const localStateChanges: VideoStateType[] = []
+      const remoteStateChanges: VideoStateType[] = []
+
+      const liveVideoUUID = await createLiveWrapper()
+      await waitJobs(servers)
+
+      {
+        const videoId = await servers[0].videos.getId({ uuid: liveVideoUUID })
+
+        const localSocket = servers[0].socketIO.getLiveNotificationSocket()
+        localSocket.on('state-change', data => localStateChanges.push(data.state))
+        localSocket.emit('subscribe', { videoId })
+      }
+
+      {
+        const videoId = await servers[1].videos.getId({ uuid: liveVideoUUID })
+
+        const remoteSocket = servers[1].socketIO.getLiveNotificationSocket()
+        remoteSocket.on('state-change', data => remoteStateChanges.push(data.state))
+        remoteSocket.emit('subscribe', { videoId })
+      }
+
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+      await waitJobs(servers)
+
+      for (const stateChanges of [ localStateChanges, remoteStateChanges ]) {
+        expect(stateChanges).to.have.length.at.least(1)
+        expect(stateChanges[stateChanges.length - 1]).to.equal(VideoState.PUBLISHED)
+      }
+
+      await stopFfmpeg(ffmpegCommand)
+
+      for (const server of servers) {
+        await server.live.waitUntilEnded({ videoId: liveVideoUUID })
+      }
+      await waitJobs(servers)
+
+      for (const stateChanges of [ localStateChanges, remoteStateChanges ]) {
+        expect(stateChanges).to.have.length.at.least(2)
+        expect(stateChanges[stateChanges.length - 1]).to.equal(VideoState.LIVE_ENDED)
+      }
+    })
+
+    it('Should correctly send views change notification', async function () {
+      this.timeout(60000)
+
+      let localLastVideoViews = 0
+      let remoteLastVideoViews = 0
+
+      const liveVideoUUID = await createLiveWrapper()
+      await waitJobs(servers)
+
+      {
+        const videoId = await servers[0].videos.getId({ uuid: liveVideoUUID })
+
+        const localSocket = servers[0].socketIO.getLiveNotificationSocket()
+        localSocket.on('views-change', (data: LiveVideoEventPayload) => { localLastVideoViews = data.viewers })
+        localSocket.emit('subscribe', { videoId })
+      }
+
+      {
+        const videoId = await servers[1].videos.getId({ uuid: liveVideoUUID })
+
+        const remoteSocket = servers[1].socketIO.getLiveNotificationSocket()
+        remoteSocket.on('views-change', (data: LiveVideoEventPayload) => { remoteLastVideoViews = data.viewers })
+        remoteSocket.emit('subscribe', { videoId })
+      }
+
+      const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+      await waitJobs(servers)
+
+      expect(localLastVideoViews).to.equal(0)
+      expect(remoteLastVideoViews).to.equal(0)
+
+      await servers[0].views.simulateView({ id: liveVideoUUID })
+      await servers[1].views.simulateView({ id: liveVideoUUID })
+
+      await waitJobs(servers)
+
+      expect(localLastVideoViews).to.equal(2)
+      expect(remoteLastVideoViews).to.equal(2)
+
+      await stopFfmpeg(ffmpegCommand)
+    })
+
+    it('Should not receive a notification after unsubscribe', async function () {
+      this.timeout(120000)
+
+      const stateChanges: VideoStateType[] = []
+
+      const liveVideoUUID = await createLiveWrapper()
+      await waitJobs(servers)
+
+      const videoId = await servers[0].videos.getId({ uuid: liveVideoUUID })
+
+      const socket = servers[0].socketIO.getLiveNotificationSocket()
+      socket.on('state-change', data => stateChanges.push(data.state))
+      socket.emit('subscribe', { videoId })
+
+      const command = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoUUID })
+
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoUUID)
+      await waitJobs(servers)
+
+      // Notifier waits before sending a notification
+      await wait(10000)
+
+      expect(stateChanges).to.have.lengthOf(1)
+      socket.emit('unsubscribe', { videoId })
+
+      await stopFfmpeg(command)
+      await waitJobs(servers)
+
+      expect(stateChanges).to.have.lengthOf(1)
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})
diff --git a/packages/tests/src/api/live/live.ts b/packages/tests/src/api/live/live.ts
new file mode 100644
index 000000000..20804f889
--- /dev/null
+++ b/packages/tests/src/api/live/live.ts
@@ -0,0 +1,766 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import { expect } from 'chai'
+import { basename, join } from 'path'
+import { getAllFiles, wait } from '@peertube/peertube-core-utils'
+import { ffprobePromise, getVideoStream } from '@peertube/peertube-ffmpeg'
+import {
+  HttpStatusCode,
+  LiveVideo,
+  LiveVideoCreate,
+  LiveVideoLatencyMode,
+  VideoDetails,
+  VideoPrivacy,
+  VideoState,
+  VideoStreamingPlaylistType
+} from '@peertube/peertube-models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  killallServers,
+  LiveCommand,
+  makeGetRequest,
+  makeRawRequest,
+  PeerTubeServer,
+  sendRTMPStream,
+  setAccessTokensToServers,
+  setDefaultVideoChannel,
+  stopFfmpeg,
+  testFfmpegStreamError,
+  waitJobs,
+  waitUntilLivePublishedOnAllServers
+} from '@peertube/peertube-server-commands'
+import { testImageGeneratedByFFmpeg } from '@tests/shared/checks.js'
+import { testLiveVideoResolutions } from '@tests/shared/live.js'
+import { SQLCommand } from '@tests/shared/sql-command.js'
+
+describe('Test live', function () {
+  let servers: PeerTubeServer[] = []
+  let commands: LiveCommand[]
+
+  before(async function () {
+    this.timeout(120000)
+
+    servers = await createMultipleServers(2)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await servers[0].config.updateCustomSubConfig({
+      newConfig: {
+        live: {
+          enabled: true,
+          allowReplay: true,
+          latencySetting: {
+            enabled: true
+          },
+          transcoding: {
+            enabled: false
+          }
+        }
+      }
+    })
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
+
+    commands = servers.map(s => s.live)
+  })
+
+  describe('Live creation, update and delete', function () {
+    let liveVideoUUID: string
+
+    it('Should create a live with the appropriate parameters', async function () {
+      this.timeout(20000)
+
+      const attributes: LiveVideoCreate = {
+        category: 1,
+        licence: 2,
+        language: 'fr',
+        description: 'super live description',
+        support: 'support field',
+        channelId: servers[0].store.channel.id,
+        nsfw: false,
+        waitTranscoding: false,
+        name: 'my super live',
+        tags: [ 'tag1', 'tag2' ],
+        commentsEnabled: false,
+        downloadEnabled: false,
+        saveReplay: true,
+        replaySettings: { privacy: VideoPrivacy.PUBLIC },
+        latencyMode: LiveVideoLatencyMode.SMALL_LATENCY,
+        privacy: VideoPrivacy.PUBLIC,
+        previewfile: 'video_short1-preview.webm.jpg',
+        thumbnailfile: 'video_short1.webm.jpg'
+      }
+
+      const live = await commands[0].create({ fields: attributes })
+      liveVideoUUID = live.uuid
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: liveVideoUUID })
+
+        expect(video.category.id).to.equal(1)
+        expect(video.licence.id).to.equal(2)
+        expect(video.language.id).to.equal('fr')
+        expect(video.description).to.equal('super live description')
+        expect(video.support).to.equal('support field')
+
+        expect(video.channel.name).to.equal(servers[0].store.channel.name)
+        expect(video.channel.host).to.equal(servers[0].store.channel.host)
+
+        expect(video.isLive).to.be.true
+
+        expect(video.nsfw).to.be.false
+        expect(video.waitTranscoding).to.be.false
+        expect(video.name).to.equal('my super live')
+        expect(video.tags).to.deep.equal([ 'tag1', 'tag2' ])
+        expect(video.commentsEnabled).to.be.false
+        expect(video.downloadEnabled).to.be.false
+        expect(video.privacy.id).to.equal(VideoPrivacy.PUBLIC)
+
+        await testImageGeneratedByFFmpeg(server.url, 'video_short1-preview.webm', video.previewPath)
+        await testImageGeneratedByFFmpeg(server.url, 'video_short1.webm', video.thumbnailPath)
+
+        const live = await server.live.get({ videoId: liveVideoUUID })
+
+        if (server.url === servers[0].url) {
+          expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
+          expect(live.streamKey).to.not.be.empty
+
+          expect(live.replaySettings).to.exist
+          expect(live.replaySettings.privacy).to.equal(VideoPrivacy.PUBLIC)
+        } else {
+          expect(live.rtmpUrl).to.not.exist
+          expect(live.streamKey).to.not.exist
+        }
+
+        expect(live.saveReplay).to.be.true
+        expect(live.latencyMode).to.equal(LiveVideoLatencyMode.SMALL_LATENCY)
+      }
+    })
+
+    it('Should have a default preview and thumbnail', async function () {
+      this.timeout(20000)
+
+      const attributes: LiveVideoCreate = {
+        name: 'default live thumbnail',
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.UNLISTED,
+        nsfw: true
+      }
+
+      const live = await commands[0].create({ fields: attributes })
+      const videoId = live.uuid
+
+      await waitJobs(servers)
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: videoId })
+        expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED)
+        expect(video.nsfw).to.be.true
+
+        await makeGetRequest({ url: server.url, path: video.thumbnailPath, expectedStatus: HttpStatusCode.OK_200 })
+        await makeGetRequest({ url: server.url, path: video.previewPath, expectedStatus: HttpStatusCode.OK_200 })
+      }
+    })
+
+    it('Should not have the live listed since nobody streams into', async function () {
+      for (const server of servers) {
+        const { total, data } = await server.videos.list()
+
+        expect(total).to.equal(0)
+        expect(data).to.have.lengthOf(0)
+      }
+    })
+
+    it('Should not be able to update a live of another server', async function () {
+      await commands[1].update({ videoId: liveVideoUUID, fields: { saveReplay: false }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+    })
+
+    it('Should update the live', async function () {
+      await commands[0].update({ videoId: liveVideoUUID, fields: { saveReplay: false, latencyMode: LiveVideoLatencyMode.DEFAULT } })
+      await waitJobs(servers)
+    })
+
+    it('Have the live updated', async function () {
+      for (const server of servers) {
+        const live = await server.live.get({ videoId: liveVideoUUID })
+
+        if (server.url === servers[0].url) {
+          expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
+          expect(live.streamKey).to.not.be.empty
+        } else {
+          expect(live.rtmpUrl).to.not.exist
+          expect(live.streamKey).to.not.exist
+        }
+
+        expect(live.saveReplay).to.be.false
+        expect(live.replaySettings).to.not.exist
+        expect(live.latencyMode).to.equal(LiveVideoLatencyMode.DEFAULT)
+      }
+    })
+
+    it('Delete the live', async function () {
+      await servers[0].videos.remove({ id: liveVideoUUID })
+      await waitJobs(servers)
+    })
+
+    it('Should have the live deleted', async function () {
+      for (const server of servers) {
+        await server.videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+        await server.live.get({ videoId: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
+      }
+    })
+  })
+
+  describe('Live filters', function () {
+    let ffmpegCommand: any
+    let liveVideoId: string
+    let vodVideoId: string
+
+    before(async function () {
+      this.timeout(240000)
+
+      vodVideoId = (await servers[0].videos.quickUpload({ name: 'vod video' })).uuid
+
+      const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].store.channel.id }
+      const live = await commands[0].create({ fields: liveOptions })
+      liveVideoId = live.uuid
+
+      ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoId })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+    })
+
+    it('Should only display lives', async function () {
+      const { data, total } = await servers[0].videos.list({ isLive: true })
+
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('live')
+    })
+
+    it('Should not display lives', async function () {
+      const { data, total } = await servers[0].videos.list({ isLive: false })
+
+      expect(total).to.equal(1)
+      expect(data).to.have.lengthOf(1)
+      expect(data[0].name).to.equal('vod video')
+    })
+
+    it('Should display my lives', async function () {
+      this.timeout(60000)
+
+      await stopFfmpeg(ffmpegCommand)
+      await waitJobs(servers)
+
+      const { data } = await servers[0].videos.listMyVideos({ isLive: true })
+
+      const result = data.every(v => v.isLive)
+      expect(result).to.be.true
+    })
+
+    it('Should not display my lives', async function () {
+      const { data } = await servers[0].videos.listMyVideos({ isLive: false })
+
+      const result = data.every(v => !v.isLive)
+      expect(result).to.be.true
+    })
+
+    after(async function () {
+      await servers[0].videos.remove({ id: vodVideoId })
+      await servers[0].videos.remove({ id: liveVideoId })
+    })
+  })
+
+  describe('Stream checks', function () {
+    let liveVideo: LiveVideo & VideoDetails
+    let rtmpUrl: string
+
+    before(function () {
+      rtmpUrl = 'rtmp://' + servers[0].hostname + ':' + servers[0].rtmpPort + ''
+    })
+
+    async function createLiveWrapper () {
+      const liveAttributes = {
+        name: 'user live',
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC,
+        saveReplay: false
+      }
+
+      const { uuid } = await commands[0].create({ fields: liveAttributes })
+
+      const live = await commands[0].get({ videoId: uuid })
+      const video = await servers[0].videos.get({ id: uuid })
+
+      return Object.assign(video, live)
+    }
+
+    it('Should not allow a stream without the appropriate path', async function () {
+      this.timeout(60000)
+
+      liveVideo = await createLiveWrapper()
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/bad-live', streamKey: liveVideo.streamKey })
+      await testFfmpegStreamError(command, true)
+    })
+
+    it('Should not allow a stream without the appropriate stream key', async function () {
+      this.timeout(60000)
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: 'bad-stream-key' })
+      await testFfmpegStreamError(command, true)
+    })
+
+    it('Should succeed with the correct params', async function () {
+      this.timeout(60000)
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
+      await testFfmpegStreamError(command, false)
+    })
+
+    it('Should list this live now someone stream into it', async function () {
+      for (const server of servers) {
+        const { total, data } = await server.videos.list()
+
+        expect(total).to.equal(1)
+        expect(data).to.have.lengthOf(1)
+
+        const video = data[0]
+        expect(video.name).to.equal('user live')
+        expect(video.isLive).to.be.true
+      }
+    })
+
+    it('Should not allow a stream on a live that was blacklisted', async function () {
+      this.timeout(60000)
+
+      liveVideo = await createLiveWrapper()
+
+      await servers[0].blacklist.add({ videoId: liveVideo.uuid })
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
+      await testFfmpegStreamError(command, true)
+    })
+
+    it('Should not allow a stream on a live that was deleted', async function () {
+      this.timeout(60000)
+
+      liveVideo = await createLiveWrapper()
+
+      await servers[0].videos.remove({ id: liveVideo.uuid })
+
+      const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
+      await testFfmpegStreamError(command, true)
+    })
+  })
+
+  describe('Live transcoding', function () {
+    let liveVideoId: string
+    let sqlCommandServer1: SQLCommand
+
+    async function createLiveWrapper (saveReplay: boolean) {
+      const liveAttributes = {
+        name: 'live video',
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC,
+        saveReplay,
+        replaySettings: saveReplay
+          ? { privacy: VideoPrivacy.PUBLIC }
+          : undefined
+      }
+
+      const { uuid } = await commands[0].create({ fields: liveAttributes })
+      return uuid
+    }
+
+    function updateConf (resolutions: number[]) {
+      return servers[0].config.updateCustomSubConfig({
+        newConfig: {
+          live: {
+            enabled: true,
+            allowReplay: true,
+            maxDuration: -1,
+            transcoding: {
+              enabled: true,
+              resolutions: {
+                '144p': resolutions.includes(144),
+                '240p': resolutions.includes(240),
+                '360p': resolutions.includes(360),
+                '480p': resolutions.includes(480),
+                '720p': resolutions.includes(720),
+                '1080p': resolutions.includes(1080),
+                '2160p': resolutions.includes(2160)
+              }
+            }
+          }
+        }
+      })
+    }
+
+    before(async function () {
+      await updateConf([])
+
+      sqlCommandServer1 = new SQLCommand(servers[0])
+    })
+
+    it('Should enable transcoding without additional resolutions', async function () {
+      this.timeout(120000)
+
+      liveVideoId = await createLiveWrapper(false)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId,
+        resolutions: [ 720 ],
+        transcoded: true
+      })
+
+      await stopFfmpeg(ffmpegCommand)
+    })
+
+    it('Should transcode audio only RTMP stream', async function () {
+      this.timeout(120000)
+
+      liveVideoId = await createLiveWrapper(false)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short_no_audio.mp4' })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      await stopFfmpeg(ffmpegCommand)
+    })
+
+    it('Should enable transcoding with some resolutions', async function () {
+      this.timeout(240000)
+
+      const resolutions = [ 240, 480 ]
+      await updateConf(resolutions)
+      liveVideoId = await createLiveWrapper(false)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId,
+        resolutions: resolutions.concat([ 720 ]),
+        transcoded: true
+      })
+
+      await stopFfmpeg(ffmpegCommand)
+    })
+
+    it('Should correctly set the appropriate bitrate depending on the input', async function () {
+      this.timeout(120000)
+
+      liveVideoId = await createLiveWrapper(false)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({
+        videoId: liveVideoId,
+        fixtureName: 'video_short.mp4',
+        copyCodecs: true
+      })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      const video = await servers[0].videos.get({ id: liveVideoId })
+
+      const masterPlaylist = video.streamingPlaylists[0].playlistUrl
+      const probe = await ffprobePromise(masterPlaylist)
+
+      const bitrates = probe.streams.map(s => parseInt(s.tags.variant_bitrate))
+      for (const bitrate of bitrates) {
+        expect(bitrate).to.exist
+        expect(isNaN(bitrate)).to.be.false
+        expect(bitrate).to.be.below(61_000_000) // video_short.mp4 bitrate
+      }
+
+      await stopFfmpeg(ffmpegCommand)
+    })
+
+    it('Should enable transcoding with some resolutions and correctly save them', async function () {
+      this.timeout(500_000)
+
+      const resolutions = [ 240, 360, 720 ]
+
+      await updateConf(resolutions)
+      liveVideoId = await createLiveWrapper(true)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId,
+        resolutions,
+        transcoded: true
+      })
+
+      await stopFfmpeg(ffmpegCommand)
+      await commands[0].waitUntilEnded({ videoId: liveVideoId })
+
+      await waitJobs(servers)
+
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+
+      const maxBitrateLimits = {
+        720: 6500 * 1000, // 60FPS
+        360: 1250 * 1000,
+        240: 700 * 1000
+      }
+
+      const minBitrateLimits = {
+        720: 4800 * 1000,
+        360: 1000 * 1000,
+        240: 550 * 1000
+      }
+
+      for (const server of servers) {
+        const video = await server.videos.get({ id: liveVideoId })
+
+        expect(video.state.id).to.equal(VideoState.PUBLISHED)
+        expect(video.duration).to.be.greaterThan(1)
+        expect(video.files).to.have.lengthOf(0)
+
+        const hlsPlaylist = video.streamingPlaylists.find(s => s.type === VideoStreamingPlaylistType.HLS)
+        await makeRawRequest({ url: hlsPlaylist.playlistUrl, expectedStatus: HttpStatusCode.OK_200 })
+        await makeRawRequest({ url: hlsPlaylist.segmentsSha256Url, expectedStatus: HttpStatusCode.OK_200 })
+
+        // We should have generated random filenames
+        expect(basename(hlsPlaylist.playlistUrl)).to.not.equal('master.m3u8')
+        expect(basename(hlsPlaylist.segmentsSha256Url)).to.not.equal('segments-sha256.json')
+
+        expect(hlsPlaylist.files).to.have.lengthOf(resolutions.length)
+
+        for (const resolution of resolutions) {
+          const file = hlsPlaylist.files.find(f => f.resolution.id === resolution)
+
+          expect(file).to.exist
+          expect(file.size).to.be.greaterThan(1)
+
+          if (resolution >= 720) {
+            expect(file.fps).to.be.approximately(60, 10)
+          } else {
+            expect(file.fps).to.be.approximately(30, 3)
+          }
+
+          const filename = basename(file.fileUrl)
+          expect(filename).to.not.contain(video.uuid)
+
+          const segmentPath = servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', video.uuid, filename))
+
+          const probe = await ffprobePromise(segmentPath)
+          const videoStream = await getVideoStream(segmentPath, probe)
+
+          expect(probe.format.bit_rate).to.be.below(maxBitrateLimits[videoStream.height])
+          expect(probe.format.bit_rate).to.be.at.least(minBitrateLimits[videoStream.height])
+
+          await makeRawRequest({ url: file.torrentUrl, expectedStatus: HttpStatusCode.OK_200 })
+          await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
+        }
+      }
+    })
+
+    it('Should not generate an upper resolution than original file', async function () {
+      this.timeout(500_000)
+
+      const resolutions = [ 240, 480 ]
+      await updateConf(resolutions)
+
+      await servers[0].config.updateExistingSubConfig({
+        newConfig: {
+          live: {
+            transcoding: {
+              alwaysTranscodeOriginalResolution: false
+            }
+          }
+        }
+      })
+
+      liveVideoId = await createLiveWrapper(true)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId,
+        resolutions,
+        transcoded: true
+      })
+
+      await stopFfmpeg(ffmpegCommand)
+      await commands[0].waitUntilEnded({ videoId: liveVideoId })
+
+      await waitJobs(servers)
+
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+
+      const video = await servers[0].videos.get({ id: liveVideoId })
+      const hlsFiles = video.streamingPlaylists[0].files
+
+      expect(video.files).to.have.lengthOf(0)
+      expect(hlsFiles).to.have.lengthOf(resolutions.length)
+
+      // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
+      expect(getAllFiles(video).map(f => f.resolution.id).sort()).to.deep.equal(resolutions)
+    })
+
+    it('Should only keep the original resolution if all resolutions are disabled', async function () {
+      this.timeout(600_000)
+
+      await updateConf([])
+      liveVideoId = await createLiveWrapper(true)
+
+      const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+      await waitJobs(servers)
+
+      await testLiveVideoResolutions({
+        originServer: servers[0],
+        sqlCommand: sqlCommandServer1,
+        servers,
+        liveVideoId,
+        resolutions: [ 720 ],
+        transcoded: true
+      })
+
+      await stopFfmpeg(ffmpegCommand)
+      await commands[0].waitUntilEnded({ videoId: liveVideoId })
+
+      await waitJobs(servers)
+
+      await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
+
+      const video = await servers[0].videos.get({ id: liveVideoId })
+      const hlsFiles = video.streamingPlaylists[0].files
+
+      expect(video.files).to.have.lengthOf(0)
+      expect(hlsFiles).to.have.lengthOf(1)
+
+      expect(hlsFiles[0].resolution.id).to.equal(720)
+    })
+
+    after(async function () {
+      await sqlCommandServer1.cleanup()
+    })
+  })
+
+  describe('After a server restart', function () {
+    let liveVideoId: string
+    let liveVideoReplayId: string
+    let permanentLiveVideoReplayId: string
+
+    let permanentLiveReplayName: string
+
+    let beforeServerRestart: Date
+
+    async function createLiveWrapper (options: { saveReplay: boolean, permanent: boolean }) {
+      const liveAttributes: LiveVideoCreate = {
+        name: 'live video',
+        channelId: servers[0].store.channel.id,
+        privacy: VideoPrivacy.PUBLIC,
+        saveReplay: options.saveReplay,
+        replaySettings: options.saveReplay
+          ? { privacy: VideoPrivacy.PUBLIC }
+          : undefined,
+        permanentLive: options.permanent
+      }
+
+      const { uuid } = await commands[0].create({ fields: liveAttributes })
+      return uuid
+    }
+
+    before(async function () {
+      this.timeout(600_000)
+
+      liveVideoId = await createLiveWrapper({ saveReplay: false, permanent: false })
+      liveVideoReplayId = await createLiveWrapper({ saveReplay: true, permanent: false })
+      permanentLiveVideoReplayId = await createLiveWrapper({ saveReplay: true, permanent: true })
+
+      await Promise.all([
+        commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId }),
+        commands[0].sendRTMPStreamInVideo({ videoId: permanentLiveVideoReplayId }),
+        commands[0].sendRTMPStreamInVideo({ videoId: liveVideoReplayId })
+      ])
+
+      await Promise.all([
+        commands[0].waitUntilPublished({ videoId: liveVideoId }),
+        commands[0].waitUntilPublished({ videoId: permanentLiveVideoReplayId }),
+        commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
+      ])
+
+      for (const videoUUID of [ liveVideoId, liveVideoReplayId, permanentLiveVideoReplayId ]) {
+        await commands[0].waitUntilSegmentGeneration({
+          server: servers[0],
+          videoUUID,
+          playlistNumber: 0,
+          segment: 2
+        })
+      }
+
+      {
+        const video = await servers[0].videos.get({ id: permanentLiveVideoReplayId })
+        permanentLiveReplayName = video.name + ' - ' + new Date(video.publishedAt).toLocaleString()
+      }
+
+      await killallServers([ servers[0] ])
+
+      beforeServerRestart = new Date()
+      await servers[0].run()
+
+      await wait(5000)
+      await waitJobs(servers)
+    })
+
+    it('Should cleanup lives', async function () {
+      this.timeout(60000)
+
+      await commands[0].waitUntilEnded({ videoId: liveVideoId })
+      await commands[0].waitUntilWaiting({ videoId: permanentLiveVideoReplayId })
+    })
+
+    it('Should save a non permanent live replay', async function () {
+      this.timeout(240000)
+
+      await commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
+
+      const session = await commands[0].getReplaySession({ videoId: liveVideoReplayId })
+      expect(session.endDate).to.exist
+      expect(new Date(session.endDate)).to.be.above(beforeServerRestart)
+    })
+
+    it('Should have saved a permanent live replay', async function () {
+      this.timeout(120000)
+
+      const { data } = await servers[0].videos.listMyVideos({ sort: '-publishedAt' })
+      expect(data.find(v => v.name === permanentLiveReplayName)).to.exist
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})