X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Fobject-storage%2Flive.ts;h=07ff4763b9e604abf211f2427bac766470de307e;hb=cffef25313bdf7a6c435f56ac6715fdd91acf7b3;hp=0958ffe0ffbd2478613d388ce64e642a8c55df63;hpb=863477173efa82a4412d2e522aa46462249f9199;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/tests/api/object-storage/live.ts b/server/tests/api/object-storage/live.ts index 0958ffe0f..07ff4763b 100644 --- a/server/tests/api/object-storage/live.ts +++ b/server/tests/api/object-storage/live.ts @@ -1,14 +1,14 @@ /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ import { expect } from 'chai' -import { expectStartWith } from '@server/tests/shared' -import { areObjectStorageTestsDisabled } from '@shared/core-utils' -import { HttpStatusCode, LiveVideoCreate, VideoFile, VideoPrivacy } from '@shared/models' +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, - killallServers, makeRawRequest, ObjectStorageCommand, PeerTubeServer, @@ -27,6 +27,7 @@ async function createLive (server: PeerTubeServer, permanent: boolean) { privacy: VideoPrivacy.PUBLIC, name: 'my super live', saveReplay: true, + replaySettings: { privacy: VideoPrivacy.PUBLIC }, permanentLive: permanent } @@ -35,63 +36,82 @@ async function createLive (server: PeerTubeServer, permanent: boolean) { return uuid } -async function checkFiles (files: VideoFile[]) { - for (const file of files) { - expectStartWith(file.fileUrl, ObjectStorageCommand.getPlaylistBaseUrl()) +async function checkFilesExist (options: { + servers: PeerTubeServer[] + videoUUID: string + numberOfFiles: number + objectStorage: ObjectStorageCommand +}) { + const { servers, videoUUID, numberOfFiles, objectStorage } = options - await makeRawRequest(file.fileUrl, HttpStatusCode.OK_200) - } -} + for (const server of servers) { + const video = await server.videos.get({ id: videoUUID }) -async function getFiles (server: PeerTubeServer, videoUUID: string) { - const video = await server.videos.get({ id: videoUUID }) + expect(video.files).to.have.lengthOf(0) + expect(video.streamingPlaylists).to.have.lengthOf(1) - expect(video.files).to.have.lengthOf(0) - expect(video.streamingPlaylists).to.have.lengthOf(1) - - return video.streamingPlaylists[0].files -} + const files = video.streamingPlaylists[0].files + expect(files).to.have.lengthOf(numberOfFiles) -async function streamAndEnd (servers: PeerTubeServer[], liveUUID: string) { - const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveUUID }) - await waitUntilLivePublishedOnAllServers(servers, liveUUID) + for (const file of files) { + expectStartWith(file.fileUrl, objectStorage.getMockPlaylistBaseUrl()) - const videoLiveDetails = await servers[0].videos.get({ id: liveUUID }) - const liveDetails = await servers[0].live.get({ videoId: liveUUID }) - - await stopFfmpeg(ffmpegCommand) - - if (liveDetails.permanentLive) { - await waitUntilLiveWaitingOnAllServers(servers, liveUUID) - } else { - await waitUntilLiveReplacedByReplayOnAllServers(servers, liveUUID) + await makeRawRequest({ url: file.fileUrl, expectedStatus: HttpStatusCode.OK_200 }) + } } +} - await waitJobs(servers) +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 + }) + } - return { videoLiveDetails, liveDetails } + await server.live.getSegmentFile({ + videoUUID, + playlistNumber: 0, + segment: 0, + objectStorage, + expectedStatus: HttpStatusCode.NOT_FOUND_404 + }) } describe('Object storage for lives', function () { - if (areObjectStorageTestsDisabled()) return + if (areMockObjectStorageTestsDisabled()) return let servers: PeerTubeServer[] + let sqlCommandServer1: SQLCommand + const objectStorage = new ObjectStorageCommand() before(async function () { this.timeout(120000) - await ObjectStorageCommand.prepareDefaultBuckets() - - servers = await createMultipleServers(2, ObjectStorageCommand.getDefaultConfig()) + 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', async function () { + describe('Without live transcoding', function () { let videoUUID: string before(async function () { @@ -100,61 +120,192 @@ describe('Object storage for lives', function () { videoUUID = await createLive(servers[0], false) }) - it('Should create a live and save the replay on object storage', async function () { + it('Should create a live and publish it on object storage', async function () { this.timeout(220000) - await streamAndEnd(servers, videoUUID) + const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUID }) + await waitUntilLivePublishedOnAllServers(servers, videoUUID) - for (const server of servers) { - const files = await getFiles(server, videoUUID) - expect(files).to.have.lengthOf(1) + await testLiveVideoResolutions({ + originServer: servers[0], + sqlCommand: sqlCommandServer1, + servers, + liveVideoId: videoUUID, + resolutions: [ 720 ], + transcoded: false, + objectStorage + }) - await checkFiles(files) - } + 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', async function () { - let videoUUIDPermanent: string - let videoUUIDNonPermanent: string + 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 + }) - videoUUIDPermanent = await createLive(servers[0], true) - videoUUIDNonPermanent = await createLive(servers[0], false) + 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 }) + }) }) - it('Should create a live and save the replay on object storage', async function () { - this.timeout(240000) + 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 streamAndEnd(servers, videoUUIDNonPermanent) + await checkFilesExist({ servers, videoUUID: replay.uuid, numberOfFiles: 5, objectStorage }) + }) - for (const server of servers) { - const files = await getFiles(server, videoUUIDNonPermanent) - expect(files).to.have.lengthOf(5) + 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() - await checkFiles(files) + 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 create a live and save the replay of permanent live on object storage', async function () { + it('Should publish a live and replace the base url', async function () { this.timeout(240000) - const { videoLiveDetails } = await streamAndEnd(servers, videoUUIDPermanent) + const videoUUIDPermanent = await createLive(servers[0], true) - const replay = await findExternalSavedVideo(servers[0], videoLiveDetails) + const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: videoUUIDPermanent }) + await waitUntilLivePublishedOnAllServers(servers, videoUUIDPermanent) - for (const server of servers) { - const files = await getFiles(server, replay.uuid) - expect(files).to.have.lengthOf(5) + await testLiveVideoResolutions({ + originServer: servers[0], + sqlCommand: sqlCommandServer1, + servers, + liveVideoId: videoUUIDPermanent, + resolutions: [ 720 ], + transcoded: true, + objectStorage, + objectStorageBaseUrl: baseMockUrl + }) - await checkFiles(files) - } + await stopFfmpeg(ffmpegCommand) }) }) after(async function () { - await killallServers(servers) + await sqlCommandServer1.cleanup() + await objectStorage.cleanupMock() + + await cleanupTests(servers) }) })