/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ import { expect } from 'chai' import { expectStartWith, MockObjectStorageProxy, SQLCommand, testLiveVideoResolutions } from '@server/tests/shared' import { areMockObjectStorageTestsDisabled } from '@shared/core-utils' import { HttpStatusCode, LiveVideoCreate, VideoPrivacy } from '@shared/models' import { cleanupTests, createMultipleServers, doubleFollow, findExternalSavedVideo, makeRawRequest, ObjectStorageCommand, PeerTubeServer, setAccessTokensToServers, setDefaultVideoChannel, stopFfmpeg, waitJobs, waitUntilLivePublishedOnAllServers, waitUntilLiveReplacedByReplayOnAllServers, waitUntilLiveWaitingOnAllServers } from '@shared/server-commands' async function createLive (server: PeerTubeServer, permanent: boolean) { const attributes: LiveVideoCreate = { channelId: server.store.channel.id, privacy: VideoPrivacy.PUBLIC, name: 'my super live', saveReplay: true, replaySettings: { privacy: VideoPrivacy.PUBLIC }, permanentLive: permanent } const { uuid } = await server.live.create({ fields: attributes }) return uuid } async function checkFilesExist (options: { servers: PeerTubeServer[] videoUUID: string numberOfFiles: number objectStorage: ObjectStorageCommand }) { const { servers, videoUUID, numberOfFiles, objectStorage } = options for (const server of servers) { const video = await server.videos.get({ id: videoUUID }) expect(video.files).to.have.lengthOf(0) expect(video.streamingPlaylists).to.have.lengthOf(1) const files = video.streamingPlaylists[0].files expect(files).to.have.lengthOf(numberOfFiles) for (const file of files) { expectStartWith(file.fileUrl, objectStorage.getMockPlaylistBaseUrl()) await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 }) } } } async function checkFilesCleanup (options: { server: PeerTubeServer videoUUID: string resolutions: number[] objectStorage: ObjectStorageCommand }) { const { server, videoUUID, resolutions, objectStorage } = options const resolutionFiles = resolutions.map((_value, i) => `${i}.m3u8`) for (const playlistName of [ 'master.m3u8' ].concat(resolutionFiles)) { await server.live.getPlaylistFile({ videoUUID, playlistName, expectedStatus: HttpStatusCode.NOT_FOUND_404, objectStorage }) } await server.live.getSegmentFile({ videoUUID, playlistNumber: 0, segment: 0, objectStorage, expectedStatus: HttpStatusCode.NOT_FOUND_404 }) } describe('Object storage for lives', function () { if (areMockObjectStorageTestsDisabled()) return let servers: PeerTubeServer[] let sqlCommandServer1: SQLCommand const objectStorage = new ObjectStorageCommand() before(async function () { this.timeout(120000) await objectStorage.prepareDefaultMockBuckets() servers = await createMultipleServers(2, objectStorage.getDefaultMockConfig()) await setAccessTokensToServers(servers) await setDefaultVideoChannel(servers) await doubleFollow(servers[0], servers[1]) await servers[0].config.enableTranscoding() sqlCommandServer1 = new SQLCommand(servers[0]) }) describe('Without live transcoding', function () { let videoUUID: string before(async function () { await servers[0].config.enableLive({ transcoding: false }) videoUUID = await createLive(servers[0], false) }) it('Should create a live and publish it on object storage', async function () { this.timeout(220000) const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID }) await waitUntilLivePublishedOnAllServers(servers, videoUUID) await testLiveVideoResolutions({ originServer: servers[0], sqlCommand: sqlCommandServer1, servers, liveVideoId: videoUUID, resolutions: [ 720 ], transcoded: false, objectStorage }) await stopFfmpeg(ffmpegCommand) }) it('Should have saved the replay on object storage', async function () { this.timeout(220000) await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUID) await waitJobs(servers) await checkFilesExist({ servers, videoUUID, numberOfFiles: 1, objectStorage }) }) it('Should have cleaned up live files from object storage', async function () { await checkFilesCleanup({ server: servers[0], videoUUID, resolutions: [ 720 ], objectStorage }) }) }) describe('With live transcoding', function () { const resolutions = [ 720, 480, 360, 240, 144 ] before(async function () { await servers[0].config.enableLive({ transcoding: true }) }) describe('Normal replay', function () { let videoUUIDNonPermanent: string before(async function () { videoUUIDNonPermanent = await createLive(servers[0], false) }) it('Should create a live and publish it on object storage', async function () { this.timeout(240000) const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDNonPermanent }) await waitUntilLivePublishedOnAllServers(servers, videoUUIDNonPermanent) await testLiveVideoResolutions({ originServer: servers[0], sqlCommand: sqlCommandServer1, servers, liveVideoId: videoUUIDNonPermanent, resolutions, transcoded: true, objectStorage }) await stopFfmpeg(ffmpegCommand) }) it('Should have saved the replay on object storage', async function () { this.timeout(220000) await waitUntilLiveReplacedByReplayOnAllServers(servers, videoUUIDNonPermanent) await waitJobs(servers) await checkFilesExist({ servers, videoUUID: videoUUIDNonPermanent, numberOfFiles: 5, objectStorage }) }) it('Should have cleaned up live files from object storage', async function () { await checkFilesCleanup({ server: servers[0], videoUUID: videoUUIDNonPermanent, resolutions, objectStorage }) }) }) describe('Permanent replay', function () { let videoUUIDPermanent: string before(async function () { videoUUIDPermanent = await createLive(servers[0], true) }) it('Should create a live and publish it on object storage', async function () { this.timeout(240000) const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent }) await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent) await testLiveVideoResolutions({ originServer: servers[0], sqlCommand: sqlCommandServer1, servers, liveVideoId: videoUUIDPermanent, resolutions, transcoded: true, objectStorage }) await stopFfmpeg(ffmpegCommand) }) it('Should have saved the replay on object storage', async function () { this.timeout(220000) await waitUntilLiveWaitingOnAllServers(servers, videoUUIDPermanent) await waitJobs(servers) const videoLiveDetails = await servers[0].videos.get({ id: videoUUIDPermanent }) const replay = await findExternalSavedVideo(servers[0], videoLiveDetails) await checkFilesExist({ servers, videoUUID: replay.uuid, numberOfFiles: 5, objectStorage }) }) it('Should have cleaned up live files from object storage', async function () { await checkFilesCleanup({ server: servers[0], videoUUID: videoUUIDPermanent, resolutions, objectStorage }) }) }) }) describe('With object storage base url', function () { const mockObjectStorageProxy = new MockObjectStorageProxy() let baseMockUrl: string before(async function () { this.timeout(120000) const port = await mockObjectStorageProxy.initialize() const bucketName = objectStorage.getMockStreamingPlaylistsBucketName() baseMockUrl = `http://127.0.0.1:${port}/${bucketName}` await objectStorage.prepareDefaultMockBuckets() const config = { object_storage: { enabled: true, endpoint: 'http://' + ObjectStorageCommand.getMockEndpointHost(), region: ObjectStorageCommand.getMockRegion(), credentials: ObjectStorageCommand.getMockCredentialsConfig(), streaming_playlists: { bucket_name: bucketName, prefix: '', base_url: baseMockUrl } } } await servers[0].kill() await servers[0].run(config) await servers[0].config.enableLive({ transcoding: true, resolutions: 'min' }) }) it('Should publish a live and replace the base url', async function () { this.timeout(240000) const videoUUIDPermanent = await createLive(servers[0], true) const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent }) await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent) await testLiveVideoResolutions({ originServer: servers[0], sqlCommand: sqlCommandServer1, servers, liveVideoId: videoUUIDPermanent, resolutions: [ 720 ], transcoded: true, objectStorage, objectStorageBaseUrl: baseMockUrl }) await stopFfmpeg(ffmpegCommand) }) }) after(async function () { await sqlCommandServer1.cleanup() await objectStorage.cleanupMock() await cleanupTests(servers) }) })