/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
-import * as chai from 'chai'
-import { expectStartWith } from '@server/tests/shared'
-import { areObjectStorageTestsDisabled } from '@shared/core-utils'
-import { HttpStatusCode, LiveVideoCreate, VideoFile, VideoPrivacy } from '@shared/models'
+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,
- killallServers,
makeRawRequest,
ObjectStorageCommand,
PeerTubeServer,
waitUntilLiveWaitingOnAllServers
} from '@shared/server-commands'
-const expect = chai.expect
-
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
}
return uuid
}
-async function checkFiles (files: VideoFile[]) {
- for (const file of files) {
- expectStartWith(file.fileUrl, ObjectStorageCommand.getPlaylistBaseUrl())
-
- await makeRawRequest(file.fileUrl, HttpStatusCode.OK_200)
- }
-}
+async function checkFilesExist (options: {
+ servers: PeerTubeServer[]
+ videoUUID: string
+ numberOfFiles: number
+ objectStorage: ObjectStorageCommand
+}) {
+ const { servers, videoUUID, numberOfFiles, objectStorage } = options
-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)
-
- return video.streamingPlaylists[0].files
-}
+ for (const server of servers) {
+ const video = await server.videos.get({ id: videoUUID })
-async function streamAndEnd (servers: PeerTubeServer[], liveUUID: string) {
- const ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveUUID })
- await waitUntilLivePublishedOnAllServers(servers, liveUUID)
+ expect(video.files).to.have.lengthOf(0)
+ expect(video.streamingPlaylists).to.have.lengthOf(1)
- const videoLiveDetails = await servers[0].videos.get({ id: liveUUID })
- const liveDetails = await servers[0].live.get({ videoId: liveUUID })
+ const files = video.streamingPlaylists[0].files
+ expect(files).to.have.lengthOf(numberOfFiles)
- await stopFfmpeg(ffmpegCommand)
+ for (const file of files) {
+ expectStartWith(file.fileUrl, objectStorage.getMockPlaylistBaseUrl())
- 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 () {
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)
})
})