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

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