1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
import { expect } from 'chai'
import * as ffmpeg from 'fluent-ffmpeg'
import { pathExists, readdir } from 'fs-extra'
import { join } from 'path'
import { buildAbsoluteFixturePath, wait } from '../miscs'
import { PeerTubeServer } from '../server/server'
function sendRTMPStream (options: {
rtmpBaseUrl: string
streamKey: string
fixtureName?: string // default video_short.mp4
copyCodecs?: boolean // default false
}) {
const { rtmpBaseUrl, streamKey, fixtureName = 'video_short.mp4', copyCodecs = false } = options
const fixture = buildAbsoluteFixturePath(fixtureName)
const command = ffmpeg(fixture)
command.inputOption('-stream_loop -1')
command.inputOption('-re')
if (copyCodecs) {
command.outputOption('-c copy')
} else {
command.outputOption('-c:v libx264')
command.outputOption('-g 50')
command.outputOption('-keyint_min 2')
command.outputOption('-r 60')
}
command.outputOption('-f flv')
const rtmpUrl = rtmpBaseUrl + '/' + streamKey
command.output(rtmpUrl)
command.on('error', err => {
if (err?.message?.includes('Exiting normally')) return
if (process.env.DEBUG) console.error(err)
})
if (process.env.DEBUG) {
command.on('stderr', data => console.log(data))
}
command.run()
return command
}
function waitFfmpegUntilError (command: ffmpeg.FfmpegCommand, successAfterMS = 10000) {
return new Promise<void>((res, rej) => {
command.on('error', err => {
return rej(err)
})
setTimeout(() => {
res()
}, successAfterMS)
})
}
async function testFfmpegStreamError (command: ffmpeg.FfmpegCommand, shouldHaveError: boolean) {
let error: Error
try {
await waitFfmpegUntilError(command, 35000)
} catch (err) {
error = err
}
await stopFfmpeg(command)
if (shouldHaveError && !error) throw new Error('Ffmpeg did not have an error')
if (!shouldHaveError && error) throw error
}
async function stopFfmpeg (command: ffmpeg.FfmpegCommand) {
command.kill('SIGINT')
await wait(500)
}
async function waitUntilLivePublishedOnAllServers (servers: PeerTubeServer[], videoId: string) {
for (const server of servers) {
await server.live.waitUntilPublished({ videoId })
}
}
async function waitUntilLiveSavedOnAllServers (servers: PeerTubeServer[], videoId: string) {
for (const server of servers) {
await server.live.waitUntilSaved({ videoId })
}
}
async function checkLiveCleanupAfterSave (server: PeerTubeServer, videoUUID: string, resolutions: number[] = []) {
const basePath = server.servers.buildDirectory('streaming-playlists')
const hlsPath = join(basePath, 'hls', videoUUID)
if (resolutions.length === 0) {
const result = await pathExists(hlsPath)
expect(result).to.be.false
return
}
const files = await readdir(hlsPath)
// fragmented file and playlist per resolution + master playlist + segments sha256 json file
expect(files).to.have.lengthOf(resolutions.length * 2 + 2)
for (const resolution of resolutions) {
const fragmentedFile = files.find(f => f.endsWith(`-${resolution}-fragmented.mp4`))
expect(fragmentedFile).to.exist
const playlistFile = files.find(f => f.endsWith(`${resolution}.m3u8`))
expect(playlistFile).to.exist
}
const masterPlaylistFile = files.find(f => f.endsWith('-master.m3u8'))
expect(masterPlaylistFile).to.exist
const shaFile = files.find(f => f.endsWith('-segments-sha256.json'))
expect(shaFile).to.exist
}
export {
sendRTMPStream,
waitFfmpegUntilError,
testFfmpegStreamError,
stopFfmpeg,
waitUntilLivePublishedOnAllServers,
waitUntilLiveSavedOnAllServers,
checkLiveCleanupAfterSave
}
|
