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

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