123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635 |
- /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
- import 'mocha'
- import * as chai from 'chai'
- import { basename, join } from 'path'
- import { ffprobePromise, getVideoFileBitrate, getVideoStreamFromFile } from '@server/helpers/ffprobe-utils'
- import {
- checkLiveCleanupAfterSave,
- checkLiveSegmentHash,
- checkResolutionsInMasterPlaylist,
- cleanupTests,
- createMultipleServers,
- doubleFollow,
- killallServers,
- LiveCommand,
- makeRawRequest,
- PeerTubeServer,
- sendRTMPStream,
- setAccessTokensToServers,
- setDefaultVideoChannel,
- stopFfmpeg,
- testFfmpegStreamError,
- testImage,
- wait,
- waitJobs,
- waitUntilLivePublishedOnAllServers
- } from '@shared/extra-utils'
- import {
- HttpStatusCode,
- LiveVideo,
- LiveVideoCreate,
- VideoDetails,
- VideoPrivacy,
- VideoState,
- VideoStreamingPlaylistType
- } from '@shared/models'
- const expect = chai.expect
- describe('Test live', function () {
- let servers: PeerTubeServer[] = []
- let commands: LiveCommand[]
- before(async function () {
- this.timeout(120000)
- servers = await createMultipleServers(2)
- // Get the access tokens
- await setAccessTokensToServers(servers)
- await setDefaultVideoChannel(servers)
- await servers[0].config.updateCustomSubConfig({
- newConfig: {
- live: {
- enabled: true,
- allowReplay: true,
- transcoding: {
- enabled: false
- }
- }
- }
- })
- // Server 1 and server 2 follow each other
- await doubleFollow(servers[0], servers[1])
- commands = servers.map(s => s.live)
- })
- describe('Live creation, update and delete', function () {
- let liveVideoUUID: string
- it('Should create a live with the appropriate parameters', async function () {
- this.timeout(20000)
- const attributes: LiveVideoCreate = {
- category: 1,
- licence: 2,
- language: 'fr',
- description: 'super live description',
- support: 'support field',
- channelId: servers[0].store.channel.id,
- nsfw: false,
- waitTranscoding: false,
- name: 'my super live',
- tags: [ 'tag1', 'tag2' ],
- commentsEnabled: false,
- downloadEnabled: false,
- saveReplay: true,
- privacy: VideoPrivacy.PUBLIC,
- previewfile: 'video_short1-preview.webm.jpg',
- thumbnailfile: 'video_short1.webm.jpg'
- }
- const live = await commands[0].create({ fields: attributes })
- liveVideoUUID = live.uuid
- await waitJobs(servers)
- for (const server of servers) {
- const video = await server.videos.get({ id: liveVideoUUID })
- expect(video.category.id).to.equal(1)
- expect(video.licence.id).to.equal(2)
- expect(video.language.id).to.equal('fr')
- expect(video.description).to.equal('super live description')
- expect(video.support).to.equal('support field')
- expect(video.channel.name).to.equal(servers[0].store.channel.name)
- expect(video.channel.host).to.equal(servers[0].store.channel.host)
- expect(video.isLive).to.be.true
- expect(video.nsfw).to.be.false
- expect(video.waitTranscoding).to.be.false
- expect(video.name).to.equal('my super live')
- expect(video.tags).to.deep.equal([ 'tag1', 'tag2' ])
- expect(video.commentsEnabled).to.be.false
- expect(video.downloadEnabled).to.be.false
- expect(video.privacy.id).to.equal(VideoPrivacy.PUBLIC)
- await testImage(server.url, 'video_short1-preview.webm', video.previewPath)
- await testImage(server.url, 'video_short1.webm', video.thumbnailPath)
- const live = await server.live.get({ videoId: liveVideoUUID })
- if (server.url === servers[0].url) {
- expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
- expect(live.streamKey).to.not.be.empty
- } else {
- expect(live.rtmpUrl).to.be.null
- expect(live.streamKey).to.be.null
- }
- expect(live.saveReplay).to.be.true
- }
- })
- it('Should have a default preview and thumbnail', async function () {
- this.timeout(20000)
- const attributes: LiveVideoCreate = {
- name: 'default live thumbnail',
- channelId: servers[0].store.channel.id,
- privacy: VideoPrivacy.UNLISTED,
- nsfw: true
- }
- const live = await commands[0].create({ fields: attributes })
- const videoId = live.uuid
- await waitJobs(servers)
- for (const server of servers) {
- const video = await server.videos.get({ id: videoId })
- expect(video.privacy.id).to.equal(VideoPrivacy.UNLISTED)
- expect(video.nsfw).to.be.true
- await makeRawRequest(server.url + video.thumbnailPath, HttpStatusCode.OK_200)
- await makeRawRequest(server.url + video.previewPath, HttpStatusCode.OK_200)
- }
- })
- it('Should not have the live listed since nobody streams into', async function () {
- for (const server of servers) {
- const { total, data } = await server.videos.list()
- expect(total).to.equal(0)
- expect(data).to.have.lengthOf(0)
- }
- })
- it('Should not be able to update a live of another server', async function () {
- await commands[1].update({ videoId: liveVideoUUID, fields: { saveReplay: false }, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
- })
- it('Should update the live', async function () {
- this.timeout(10000)
- await commands[0].update({ videoId: liveVideoUUID, fields: { saveReplay: false } })
- await waitJobs(servers)
- })
- it('Have the live updated', async function () {
- for (const server of servers) {
- const live = await server.live.get({ videoId: liveVideoUUID })
- if (server.url === servers[0].url) {
- expect(live.rtmpUrl).to.equal('rtmp://' + server.hostname + ':' + servers[0].rtmpPort + '/live')
- expect(live.streamKey).to.not.be.empty
- } else {
- expect(live.rtmpUrl).to.be.null
- expect(live.streamKey).to.be.null
- }
- expect(live.saveReplay).to.be.false
- }
- })
- it('Delete the live', async function () {
- this.timeout(10000)
- await servers[0].videos.remove({ id: liveVideoUUID })
- await waitJobs(servers)
- })
- it('Should have the live deleted', async function () {
- for (const server of servers) {
- await server.videos.get({ id: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
- await server.live.get({ videoId: liveVideoUUID, expectedStatus: HttpStatusCode.NOT_FOUND_404 })
- }
- })
- })
- describe('Live filters', function () {
- let ffmpegCommand: any
- let liveVideoId: string
- let vodVideoId: string
- before(async function () {
- this.timeout(120000)
- vodVideoId = (await servers[0].videos.quickUpload({ name: 'vod video' })).uuid
- const liveOptions = { name: 'live', privacy: VideoPrivacy.PUBLIC, channelId: servers[0].store.channel.id }
- const live = await commands[0].create({ fields: liveOptions })
- liveVideoId = live.uuid
- ffmpegCommand = await servers[0].live.sendRTMPStreamInVideo({ videoId: liveVideoId })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
- await waitJobs(servers)
- })
- it('Should only display lives', async function () {
- const { data, total } = await servers[0].videos.list({ isLive: true })
- expect(total).to.equal(1)
- expect(data).to.have.lengthOf(1)
- expect(data[0].name).to.equal('live')
- })
- it('Should not display lives', async function () {
- const { data, total } = await servers[0].videos.list({ isLive: false })
- expect(total).to.equal(1)
- expect(data).to.have.lengthOf(1)
- expect(data[0].name).to.equal('vod video')
- })
- it('Should display my lives', async function () {
- this.timeout(60000)
- await stopFfmpeg(ffmpegCommand)
- await waitJobs(servers)
- const { data } = await servers[0].videos.listMyVideos({ isLive: true })
- const result = data.every(v => v.isLive)
- expect(result).to.be.true
- })
- it('Should not display my lives', async function () {
- const { data } = await servers[0].videos.listMyVideos({ isLive: false })
- const result = data.every(v => !v.isLive)
- expect(result).to.be.true
- })
- after(async function () {
- await servers[0].videos.remove({ id: vodVideoId })
- await servers[0].videos.remove({ id: liveVideoId })
- })
- })
- describe('Stream checks', function () {
- let liveVideo: LiveVideo & VideoDetails
- let rtmpUrl: string
- before(function () {
- rtmpUrl = 'rtmp://' + servers[0].hostname + ':' + servers[0].rtmpPort + ''
- })
- async function createLiveWrapper () {
- const liveAttributes = {
- name: 'user live',
- channelId: servers[0].store.channel.id,
- privacy: VideoPrivacy.PUBLIC,
- saveReplay: false
- }
- const { uuid } = await commands[0].create({ fields: liveAttributes })
- const live = await commands[0].get({ videoId: uuid })
- const video = await servers[0].videos.get({ id: uuid })
- return Object.assign(video, live)
- }
- it('Should not allow a stream without the appropriate path', async function () {
- this.timeout(60000)
- liveVideo = await createLiveWrapper()
- const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/bad-live', streamKey: liveVideo.streamKey })
- await testFfmpegStreamError(command, true)
- })
- it('Should not allow a stream without the appropriate stream key', async function () {
- this.timeout(60000)
- const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: 'bad-stream-key' })
- await testFfmpegStreamError(command, true)
- })
- it('Should succeed with the correct params', async function () {
- this.timeout(60000)
- const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
- await testFfmpegStreamError(command, false)
- })
- it('Should list this live now someone stream into it', async function () {
- for (const server of servers) {
- const { total, data } = await server.videos.list()
- expect(total).to.equal(1)
- expect(data).to.have.lengthOf(1)
- const video = data[0]
- expect(video.name).to.equal('user live')
- expect(video.isLive).to.be.true
- }
- })
- it('Should not allow a stream on a live that was blacklisted', async function () {
- this.timeout(60000)
- liveVideo = await createLiveWrapper()
- await servers[0].blacklist.add({ videoId: liveVideo.uuid })
- const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
- await testFfmpegStreamError(command, true)
- })
- it('Should not allow a stream on a live that was deleted', async function () {
- this.timeout(60000)
- liveVideo = await createLiveWrapper()
- await servers[0].videos.remove({ id: liveVideo.uuid })
- const command = sendRTMPStream({ rtmpBaseUrl: rtmpUrl + '/live', streamKey: liveVideo.streamKey })
- await testFfmpegStreamError(command, true)
- })
- })
- describe('Live transcoding', function () {
- let liveVideoId: string
- async function createLiveWrapper (saveReplay: boolean) {
- const liveAttributes = {
- name: 'live video',
- channelId: servers[0].store.channel.id,
- privacy: VideoPrivacy.PUBLIC,
- saveReplay
- }
- const { uuid } = await commands[0].create({ fields: liveAttributes })
- return uuid
- }
- async function testVideoResolutions (liveVideoId: string, resolutions: number[]) {
- for (const server of servers) {
- const { data } = await server.videos.list()
- expect(data.find(v => v.uuid === liveVideoId)).to.exist
- const video = await server.videos.get({ id: liveVideoId })
- expect(video.streamingPlaylists).to.have.lengthOf(1)
- const hlsPlaylist = video.streamingPlaylists.find(s => s.type === VideoStreamingPlaylistType.HLS)
- expect(hlsPlaylist).to.exist
- // Only finite files are displayed
- expect(hlsPlaylist.files).to.have.lengthOf(0)
- await checkResolutionsInMasterPlaylist({ server, playlistUrl: hlsPlaylist.playlistUrl, resolutions })
- for (let i = 0; i < resolutions.length; i++) {
- const segmentNum = 3
- const segmentName = `${i}-00000${segmentNum}.ts`
- await commands[0].waitUntilSegmentGeneration({ videoUUID: video.uuid, resolution: i, segment: segmentNum })
- const subPlaylist = await servers[0].streamingPlaylists.get({
- url: `${servers[0].url}/static/streaming-playlists/hls/${video.uuid}/${i}.m3u8`
- })
- expect(subPlaylist).to.contain(segmentName)
- const baseUrlAndPath = servers[0].url + '/static/streaming-playlists/hls'
- await checkLiveSegmentHash({
- server,
- baseUrlSegment: baseUrlAndPath,
- videoUUID: video.uuid,
- segmentName,
- hlsPlaylist
- })
- }
- }
- }
- function updateConf (resolutions: number[]) {
- return servers[0].config.updateCustomSubConfig({
- newConfig: {
- live: {
- enabled: true,
- allowReplay: true,
- maxDuration: -1,
- transcoding: {
- enabled: true,
- resolutions: {
- '240p': resolutions.includes(240),
- '360p': resolutions.includes(360),
- '480p': resolutions.includes(480),
- '720p': resolutions.includes(720),
- '1080p': resolutions.includes(1080),
- '2160p': resolutions.includes(2160)
- }
- }
- }
- }
- })
- }
- before(async function () {
- await updateConf([])
- })
- it('Should enable transcoding without additional resolutions', async function () {
- this.timeout(60000)
- liveVideoId = await createLiveWrapper(false)
- const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
- await waitJobs(servers)
- await testVideoResolutions(liveVideoId, [ 720 ])
- await stopFfmpeg(ffmpegCommand)
- })
- it('Should enable transcoding with some resolutions', async function () {
- this.timeout(60000)
- const resolutions = [ 240, 480 ]
- await updateConf(resolutions)
- liveVideoId = await createLiveWrapper(false)
- const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
- await waitJobs(servers)
- await testVideoResolutions(liveVideoId, resolutions)
- await stopFfmpeg(ffmpegCommand)
- })
- it('Should correctly set the appropriate bitrate depending on the input', async function () {
- this.timeout(120000)
- liveVideoId = await createLiveWrapper(false)
- const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({
- videoId: liveVideoId,
- fixtureName: 'video_short.mp4',
- copyCodecs: true
- })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
- await waitJobs(servers)
- const video = await servers[0].videos.get({ id: liveVideoId })
- const masterPlaylist = video.streamingPlaylists[0].playlistUrl
- const probe = await ffprobePromise(masterPlaylist)
- const bitrates = probe.streams.map(s => parseInt(s.tags.variant_bitrate))
- for (const bitrate of bitrates) {
- expect(bitrate).to.exist
- expect(isNaN(bitrate)).to.be.false
- expect(bitrate).to.be.below(61_000_000) // video_short.mp4 bitrate
- }
- await stopFfmpeg(ffmpegCommand)
- })
- it('Should enable transcoding with some resolutions and correctly save them', async function () {
- this.timeout(200000)
- const resolutions = [ 240, 360, 720 ]
- await updateConf(resolutions)
- liveVideoId = await createLiveWrapper(true)
- const ffmpegCommand = await commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId, fixtureName: 'video_short2.webm' })
- await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
- await waitJobs(servers)
- await testVideoResolutions(liveVideoId, resolutions)
- await stopFfmpeg(ffmpegCommand)
- await commands[0].waitUntilEnded({ videoId: liveVideoId })
- await waitJobs(servers)
- await waitUntilLivePublishedOnAllServers(servers, liveVideoId)
- const bitrateLimits = {
- 720: 5000 * 1000, // 60FPS
- 360: 1100 * 1000,
- 240: 600 * 1000
- }
- for (const server of servers) {
- const video = await server.videos.get({ id: liveVideoId })
- expect(video.state.id).to.equal(VideoState.PUBLISHED)
- expect(video.duration).to.be.greaterThan(1)
- expect(video.files).to.have.lengthOf(0)
- const hlsPlaylist = video.streamingPlaylists.find(s => s.type === VideoStreamingPlaylistType.HLS)
- await makeRawRequest(hlsPlaylist.playlistUrl, HttpStatusCode.OK_200)
- await makeRawRequest(hlsPlaylist.segmentsSha256Url, HttpStatusCode.OK_200)
- // We should have generated random filenames
- expect(basename(hlsPlaylist.playlistUrl)).to.not.equal('master.m3u8')
- expect(basename(hlsPlaylist.segmentsSha256Url)).to.not.equal('segments-sha256.json')
- expect(hlsPlaylist.files).to.have.lengthOf(resolutions.length)
- for (const resolution of resolutions) {
- const file = hlsPlaylist.files.find(f => f.resolution.id === resolution)
- expect(file).to.exist
- expect(file.size).to.be.greaterThan(1)
- if (resolution >= 720) {
- expect(file.fps).to.be.approximately(60, 2)
- } else {
- expect(file.fps).to.be.approximately(30, 2)
- }
- const filename = basename(file.fileUrl)
- expect(filename).to.not.contain(video.uuid)
- const segmentPath = servers[0].servers.buildDirectory(join('streaming-playlists', 'hls', video.uuid, filename))
- const probe = await ffprobePromise(segmentPath)
- const videoStream = await getVideoStreamFromFile(segmentPath, probe)
- expect(probe.format.bit_rate).to.be.below(bitrateLimits[videoStream.height])
- await makeRawRequest(file.torrentUrl, HttpStatusCode.OK_200)
- await makeRawRequest(file.fileUrl, HttpStatusCode.OK_200)
- }
- }
- })
- it('Should correctly have cleaned up the live files', async function () {
- this.timeout(30000)
- await checkLiveCleanupAfterSave(servers[0], liveVideoId, [ 240, 360, 720 ])
- })
- })
- describe('After a server restart', function () {
- let liveVideoId: string
- let liveVideoReplayId: string
- async function createLiveWrapper (saveReplay: boolean) {
- const liveAttributes = {
- name: 'live video',
- channelId: servers[0].store.channel.id,
- privacy: VideoPrivacy.PUBLIC,
- saveReplay
- }
- const { uuid } = await commands[0].create({ fields: liveAttributes })
- return uuid
- }
- before(async function () {
- this.timeout(120000)
- liveVideoId = await createLiveWrapper(false)
- liveVideoReplayId = await createLiveWrapper(true)
- await Promise.all([
- commands[0].sendRTMPStreamInVideo({ videoId: liveVideoId }),
- commands[0].sendRTMPStreamInVideo({ videoId: liveVideoReplayId })
- ])
- await Promise.all([
- commands[0].waitUntilPublished({ videoId: liveVideoId }),
- commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
- ])
- await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoId, resolution: 0, segment: 2 })
- await commands[0].waitUntilSegmentGeneration({ videoUUID: liveVideoReplayId, resolution: 0, segment: 2 })
- await killallServers([ servers[0] ])
- await servers[0].run()
- await wait(5000)
- })
- it('Should cleanup lives', async function () {
- this.timeout(60000)
- await commands[0].waitUntilEnded({ videoId: liveVideoId })
- })
- it('Should save a live replay', async function () {
- this.timeout(120000)
- await commands[0].waitUntilPublished({ videoId: liveVideoReplayId })
- })
- })
- after(async function () {
- await cleanupTests(servers)
- })
- })
|