server/tests/api/object-storage/live.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import * as chai from 'chai'
   4 import { expectStartWith } from '@server/tests/shared'
   5 import { areObjectStorageTestsDisabled } from '@shared/core-utils'
   6 import { HttpStatusCode, LiveVideoCreate, VideoFile, VideoPrivacy } from '@shared/models'
   7 import {
   8   createMultipleServers,
   9   doubleFollow,
  10   findExternalSavedVideo,
  11   killallServers,
  12   makeRawRequest,
  13   ObjectStorageCommand,
  14   PeerTubeServer,
  15   setAccessTokensToServers,
  16   setDefaultVideoChannel,
  17   stopFfmpeg,
  18   waitJobs,
  19   waitUntilLivePublishedOnAllServers,
  20   waitUntilLiveReplacedByReplayOnAllServers,
  21   waitUntilLiveWaitingOnAllServers
  22 } from '@shared/server-commands'
  23
  24 const expect = chai.expect
  25
  26 async function createLive (server: PeerTubeServer, permanent: boolean) {
  27   const attributes: LiveVideoCreate = {
  28     channelId: server.store.channel.id,
  29     privacy: VideoPrivacy.PUBLIC,
  30     name: 'my super live',
  31     saveReplay: true,
  32     permanentLive: permanent
  33   }
  34
  35   const { uuid } = await server.live.create({ fields: attributes })
  36
  37   return uuid
  38 }
  39
  40 async function checkFiles (files: VideoFile[]) {
  41   for (const file of files) {
  42     expectStartWith(file.fileUrl, ObjectStorageCommand.getPlaylistBaseUrl())
  43
  44     await makeRawRequest(file.fileUrl, HttpStatusCode.OK_200)
  45   }
  46 }
  47
  48 async function getFiles (server: PeerTubeServer, videoUUID: string) {
  49   const video = await server.videos.get({ id: videoUUID })
  50
  51   expect(video.files).to.have.lengthOf(0)
  52   expect(video.streamingPlaylists).to.have.lengthOf(1)
  53
  54   return video.streamingPlaylists[0].files
  55 }
  56
  57 async function streamAndEnd (servers: PeerTubeServer[], liveUUID: string) {
  58   const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveUUID })
  59   await waitUntilLivePublishedOnAllServers(servers, liveUUID)
  60
  61   const videoLiveDetails = await servers[0].videos.get({ id: liveUUID })
  62   const liveDetails = await servers[0].live.get({ videoId: liveUUID })
  63
  64   await stopFfmpeg(ffmpegCommand)
  65
  66   if (liveDetails.permanentLive) {
  67     await waitUntilLiveWaitingOnAllServers(servers, liveUUID)
  68   } else {
  69     await waitUntilLiveReplacedByReplayOnAllServers(servers, liveUUID)
  70   }
  71
  72   await waitJobs(servers)
  73
  74   return { videoLiveDetails, liveDetails }
  75 }
  76
  77 describe('Object storage for lives', function () {
  78   if (areObjectStorageTestsDisabled()) return
  79
  80   let servers: PeerTubeServer[]
  81
  82   before(async function () {
  83     this.timeout(120000)
  84
  85     await ObjectStorageCommand.prepareDefaultBuckets()
  86
  87     servers = await createMultipleServers(2, ObjectStorageCommand.getDefaultConfig())
  88
  89     await setAccessTokensToServers(servers)
  90     await setDefaultVideoChannel(servers)
  91     await doubleFollow(servers[0], servers[1])
  92
  93     await servers[0].config.enableTranscoding()
  94   })
  95
  96   describe('Without live transcoding', async function () {
  97     let videoUUID: string
  98
  99     before(async function () {
 100       await servers[0].config.enableLive({ transcoding: false })
 101
 102       videoUUID = await createLive(servers[0], false)
 103     })
 104
 105     it('Should create a live and save the replay on object storage', async function () {
 106       this.timeout(220000)
 107
 108       await streamAndEnd(servers, videoUUID)
 109
 110       for (const server of servers) {
 111         const files = await getFiles(server, videoUUID)
 112         expect(files).to.have.lengthOf(1)
 113
 114         await checkFiles(files)
 115       }
 116     })
 117   })
 118
 119   describe('With live transcoding', async function () {
 120     let videoUUIDPermanent: string
 121     let videoUUIDNonPermanent: string
 122
 123     before(async function () {
 124       await servers[0].config.enableLive({ transcoding: true })
 125
 126       videoUUIDPermanent = await createLive(servers[0], true)
 127       videoUUIDNonPermanent = await createLive(servers[0], false)
 128     })
 129
 130     it('Should create a live and save the replay on object storage', async function () {
 131       this.timeout(240000)
 132
 133       await streamAndEnd(servers, videoUUIDNonPermanent)
 134
 135       for (const server of servers) {
 136         const files = await getFiles(server, videoUUIDNonPermanent)
 137         expect(files).to.have.lengthOf(5)
 138
 139         await checkFiles(files)
 140       }
 141     })
 142
 143     it('Should create a live and save the replay of permanent live on object storage', async function () {
 144       this.timeout(240000)
 145
 146       const { videoLiveDetails } = await streamAndEnd(servers, videoUUIDPermanent)
 147
 148       const replay = await findExternalSavedVideo(servers[0], videoLiveDetails)
 149
 150       for (const server of servers) {
 151         const files = await getFiles(server, replay.uuid)
 152         expect(files).to.have.lengthOf(5)
 153
 154         await checkFiles(files)
 155       }
 156     })
 157   })
 158
 159   after(async function () {
 160     await killallServers(servers)
 161   })
 162 })