1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
3 import { expect } from 'chai'
4 import { expectStartWith, MockObjectStorageProxy, testVideoResolutions } from '@server/tests/shared'
5 import { areMockObjectStorageTestsDisabled } from '@shared/core-utils'
6 import { HttpStatusCode, LiveVideoCreate, VideoPrivacy } from '@shared/models'
10 findExternalSavedVideo,
15 setAccessTokensToServers,
16 setDefaultVideoChannel,
19 waitUntilLivePublishedOnAllServers,
20 waitUntilLiveReplacedByReplayOnAllServers,
21 waitUntilLiveWaitingOnAllServers
22 } from '@shared/server-commands'
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',
30 replaySettings: { privacy: VideoPrivacy.PUBLIC },
31 permanentLive: permanent
34 const { uuid } = await server.live.create({ fields: attributes })
39 async function checkFilesExist (servers: PeerTubeServer[], videoUUID: string, numberOfFiles: number) {
40 for (const server of servers) {
41 const video = await server.videos.get({ id: videoUUID })
43 expect(video.files).to.have.lengthOf(0)
44 expect(video.streamingPlaylists).to.have.lengthOf(1)
46 const files = video.streamingPlaylists[0].files
47 expect(files).to.have.lengthOf(numberOfFiles)
49 for (const file of files) {
50 expectStartWith(file.fileUrl, ObjectStorageCommand.getMockPlaylistBaseUrl())
52 await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 })
57 async function checkFilesCleanup (server: PeerTubeServer, videoUUID: string, resolutions: number[]) {
58 const resolutionFiles = resolutions.map((_value, i) => `${i}.m3u8`)
60 for (const playlistName of [ 'master.m3u8' ].concat(resolutionFiles)) {
61 await server.live.getPlaylistFile({
64 expectedStatus: HttpStatusCode.NOT_FOUND_404,
69 await server.live.getSegmentFile({
74 expectedStatus: HttpStatusCode.NOT_FOUND_404
78 describe('Object storage for lives', function () {
79 if (areMockObjectStorageTestsDisabled()) return
81 let servers: PeerTubeServer[]
83 before(async function () {
86 await ObjectStorageCommand.prepareDefaultMockBuckets()
88 servers = await createMultipleServers(2, ObjectStorageCommand.getDefaultMockConfig())
90 await setAccessTokensToServers(servers)
91 await setDefaultVideoChannel(servers)
92 await doubleFollow(servers[0], servers[1])
94 await servers[0].config.enableTranscoding()
97 describe('Without live transcoding', function () {
100 before(async function () {
101 await servers[0].config.enableLive({ transcoding: false })
103 videoUUID = await createLive(servers[0], false)
106 it('Should create a live and publish it on object storage', async function () {
109 const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID })
110 await waitUntilLivePublishedOnAllServers(servers, videoUUID)
112 await testVideoResolutions({
113 originServer: servers[0],
115 liveVideoId: videoUUID,
116 resolutions: [ 720 ],
121 await stopFfmpeg(ffmpegCommand)
124 it('Should have saved the replay on object storage', async function () {
127 await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUID)
128 await waitJobs(servers)
130 await checkFilesExist(servers, videoUUID, 1)
133 it('Should have cleaned up live files from object storage', async function () {
134 await checkFilesCleanup(servers[0], videoUUID, [ 720 ])
138 describe('With live transcoding', function () {
139 const resolutions = [ 720, 480, 360, 240, 144 ]
141 before(async function () {
142 await servers[0].config.enableLive({ transcoding: true })
145 describe('Normal replay', function () {
146 let videoUUIDNonPermanent: string
148 before(async function () {
149 videoUUIDNonPermanent = await createLive(servers[0], false)
152 it('Should create a live and publish it on object storage', async function () {
155 const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDNonPermanent })
156 await waitUntilLivePublishedOnAllServers(servers, videoUUIDNonPermanent)
158 await testVideoResolutions({
159 originServer: servers[0],
161 liveVideoId: videoUUIDNonPermanent,
167 await stopFfmpeg(ffmpegCommand)
170 it('Should have saved the replay on object storage', async function () {
173 await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUIDNonPermanent)
174 await waitJobs(servers)
176 await checkFilesExist(servers, videoUUIDNonPermanent, 5)
179 it('Should have cleaned up live files from object storage', async function () {
180 await checkFilesCleanup(servers[0], videoUUIDNonPermanent, resolutions)
184 describe('Permanent replay', function () {
185 let videoUUIDPermanent: string
187 before(async function () {
188 videoUUIDPermanent = await createLive(servers[0], true)
191 it('Should create a live and publish it on object storage', async function () {
194 const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent })
195 await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent)
197 await testVideoResolutions({
198 originServer: servers[0],
200 liveVideoId: videoUUIDPermanent,
206 await stopFfmpeg(ffmpegCommand)
209 it('Should have saved the replay on object storage', async function () {
212 await waitUntilLiveWaitingOnAllServers(servers, videoUUIDPermanent)
213 await waitJobs(servers)
215 const videoLiveDetails = await servers[0].videos.get({ id: videoUUIDPermanent })
216 const replay = await findExternalSavedVideo(servers[0], videoLiveDetails)
218 await checkFilesExist(servers, replay.uuid, 5)
221 it('Should have cleaned up live files from object storage', async function () {
222 await checkFilesCleanup(servers[0], videoUUIDPermanent, resolutions)
227 describe('With object storage base url', function () {
228 const mockObjectStorageProxy = new MockObjectStorageProxy()
229 let baseMockUrl: string
231 before(async function () {
234 const port = await mockObjectStorageProxy.initialize()
235 baseMockUrl = `http://127.0.0.1:${port}/streaming-playlists`
237 await ObjectStorageCommand.createMockBucket('streaming-playlists')
242 endpoint: 'http://' + ObjectStorageCommand.getMockEndpointHost(),
243 region: ObjectStorageCommand.getMockRegion(),
245 credentials: ObjectStorageCommand.getMockCredentialsConfig(),
247 streaming_playlists: {
248 bucket_name: 'streaming-playlists',
250 base_url: baseMockUrl
255 await servers[0].kill()
256 await servers[0].run(config)
258 await servers[0].config.enableLive({ transcoding: true, resolutions: 'min' })
261 it('Should publish a live and replace the base url', async function () {
264 const videoUUIDPermanent = await createLive(servers[0], true)
266 const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent })
267 await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent)
269 await testVideoResolutions({
270 originServer: servers[0],
272 liveVideoId: videoUUIDPermanent,
273 resolutions: [ 720 ],
276 objectStorageBaseUrl: baseMockUrl
279 await stopFfmpeg(ffmpegCommand)
283 after(async function () {
284 await killallServers(servers)