shared/extra-utils/videos/live.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import { expect } from 'chai'
   4 import * as ffmpeg from 'fluent-ffmpeg'
   5 import { pathExists, readdir } from 'fs-extra'
   6 import { omit } from 'lodash'
   7 import { join } from 'path'
   8 import { LiveVideo, LiveVideoCreate, LiveVideoUpdate, VideoDetails, VideoState } from '@shared/models'
   9 import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
  10 import { buildAbsoluteFixturePath, buildServerDirectory, wait } from '../miscs/miscs'
  11 import { makeGetRequest, makePutBodyRequest, makeUploadRequest } from '../requests/requests'
  12 import { ServerInfo, waitUntilLog } from '../server/servers'
  13 import { getVideoWithToken } from './videos'
  14
  15 function getLive (url: string, token: string, videoId: number | string, statusCodeExpected = HttpStatusCode.OK_200) {
  16   const path = '/api/v1/videos/live'
  17
  18   return makeGetRequest({
  19     url,
  20     token,
  21     path: path + '/' + videoId,
  22     statusCodeExpected
  23   })
  24 }
  25
  26 function updateLive (
  27   url: string,
  28   token: string,
  29   videoId: number | string,
  30   fields: LiveVideoUpdate,
  31   statusCodeExpected = HttpStatusCode.NO_CONTENT_204
  32 ) {
  33   const path = '/api/v1/videos/live'
  34
  35   return makePutBodyRequest({
  36     url,
  37     token,
  38     path: path + '/' + videoId,
  39     fields,
  40     statusCodeExpected
  41   })
  42 }
  43
  44 function createLive (url: string, token: string, fields: LiveVideoCreate, statusCodeExpected = HttpStatusCode.OK_200) {
  45   const path = '/api/v1/videos/live'
  46
  47   const attaches: any = {}
  48   if (fields.thumbnailfile) attaches.thumbnailfile = fields.thumbnailfile
  49   if (fields.previewfile) attaches.previewfile = fields.previewfile
  50
  51   const updatedFields = omit(fields, 'thumbnailfile', 'previewfile')
  52
  53   return makeUploadRequest({
  54     url,
  55     path,
  56     token,
  57     attaches,
  58     fields: updatedFields,
  59     statusCodeExpected
  60   })
  61 }
  62
  63 async function sendRTMPStreamInVideo (url: string, token: string, videoId: number | string, fixtureName?: string) {
  64   const res = await getLive(url, token, videoId)
  65   const videoLive = res.body as LiveVideo
  66
  67   return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey, fixtureName)
  68 }
  69
  70 function sendRTMPStream (rtmpBaseUrl: string, streamKey: string, fixtureName = 'video_short.mp4') {
  71   const fixture = buildAbsoluteFixturePath(fixtureName)
  72
  73   const command = ffmpeg(fixture)
  74   command.inputOption('-stream_loop -1')
  75   command.inputOption('-re')
  76   command.outputOption('-c:v libx264')
  77   command.outputOption('-g 50')
  78   command.outputOption('-keyint_min 2')
  79   command.outputOption('-r 60')
  80   command.outputOption('-f flv')
  81
  82   const rtmpUrl = rtmpBaseUrl + '/' + streamKey
  83   command.output(rtmpUrl)
  84
  85   command.on('error', err => {
  86     if (err?.message?.includes('Exiting normally')) return
  87
  88     if (process.env.DEBUG) console.error(err)
  89   })
  90
  91   if (process.env.DEBUG) {
  92     command.on('stderr', data => console.log(data))
  93   }
  94
  95   command.run()
  96
  97   return command
  98 }
  99
 100 function waitFfmpegUntilError (command: ffmpeg.FfmpegCommand, successAfterMS = 10000) {
 101   return new Promise<void>((res, rej) => {
 102     command.on('error', err => {
 103       return rej(err)
 104     })
 105
 106     setTimeout(() => {
 107       res()
 108     }, successAfterMS)
 109   })
 110 }
 111
 112 async function runAndTestFfmpegStreamError (url: string, token: string, videoId: number | string, shouldHaveError: boolean) {
 113   const command = await sendRTMPStreamInVideo(url, token, videoId)
 114
 115   return testFfmpegStreamError(command, shouldHaveError)
 116 }
 117
 118 async function testFfmpegStreamError (command: ffmpeg.FfmpegCommand, shouldHaveError: boolean) {
 119   let error: Error
 120
 121   try {
 122     await waitFfmpegUntilError(command, 35000)
 123   } catch (err) {
 124     error = err
 125   }
 126
 127   await stopFfmpeg(command)
 128
 129   if (shouldHaveError && !error) throw new Error('Ffmpeg did not have an error')
 130   if (!shouldHaveError && error) throw error
 131 }
 132
 133 async function stopFfmpeg (command: ffmpeg.FfmpegCommand) {
 134   command.kill('SIGINT')
 135
 136   await wait(500)
 137 }
 138
 139 function waitUntilLivePublished (url: string, token: string, videoId: number | string) {
 140   return waitUntilLiveState(url, token, videoId, VideoState.PUBLISHED)
 141 }
 142
 143 function waitUntilLiveWaiting (url: string, token: string, videoId: number | string) {
 144   return waitUntilLiveState(url, token, videoId, VideoState.WAITING_FOR_LIVE)
 145 }
 146
 147 function waitUntilLiveEnded (url: string, token: string, videoId: number | string) {
 148   return waitUntilLiveState(url, token, videoId, VideoState.LIVE_ENDED)
 149 }
 150
 151 function waitUntilLiveSegmentGeneration (server: ServerInfo, videoUUID: string, resolutionNum: number, segmentNum: number) {
 152   const segmentName = `${resolutionNum}-00000${segmentNum}.ts`
 153   return waitUntilLog(server, `${videoUUID}/${segmentName}`, 2, false)
 154 }
 155
 156 async function waitUntilLiveState (url: string, token: string, videoId: number | string, state: VideoState) {
 157   let video: VideoDetails
 158
 159   do {
 160     const res = await getVideoWithToken(url, token, videoId)
 161     video = res.body
 162
 163     await wait(500)
 164   } while (video.state.id !== state)
 165 }
 166
 167 async function waitUntilLiveSaved (url: string, token: string, videoId: number | string) {
 168   let video: VideoDetails
 169
 170   do {
 171     const res = await getVideoWithToken(url, token, videoId)
 172     video = res.body
 173
 174     await wait(500)
 175   } while (video.isLive === true && video.state.id !== VideoState.PUBLISHED)
 176 }
 177
 178 async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resolutions: number[] = []) {
 179   const basePath = buildServerDirectory(server, 'streaming-playlists')
 180   const hlsPath = join(basePath, 'hls', videoUUID)
 181
 182   if (resolutions.length === 0) {
 183     const result = await pathExists(hlsPath)
 184     expect(result).to.be.false
 185
 186     return
 187   }
 188
 189   const files = await readdir(hlsPath)
 190
 191   // fragmented file and playlist per resolution + master playlist + segments sha256 json file
 192   expect(files).to.have.lengthOf(resolutions.length * 2 + 2)
 193
 194   for (const resolution of resolutions) {
 195     expect(files).to.contain(`${videoUUID}-${resolution}-fragmented.mp4`)
 196     expect(files).to.contain(`${resolution}.m3u8`)
 197   }
 198
 199   expect(files).to.contain('master.m3u8')
 200   expect(files).to.contain('segments-sha256.json')
 201 }
 202
 203 async function getPlaylistsCount (server: ServerInfo, videoUUID: string) {
 204   const basePath = buildServerDirectory(server, 'streaming-playlists')
 205   const hlsPath = join(basePath, 'hls', videoUUID)
 206
 207   const files = await readdir(hlsPath)
 208
 209   return files.filter(f => f.endsWith('.m3u8')).length
 210 }
 211
 212 // ---------------------------------------------------------------------------
 213
 214 export {
 215   getLive,
 216   getPlaylistsCount,
 217   waitUntilLiveSaved,
 218   waitUntilLivePublished,
 219   updateLive,
 220   createLive,
 221   runAndTestFfmpegStreamError,
 222   checkLiveCleanup,
 223   waitUntilLiveSegmentGeneration,
 224   stopFfmpeg,
 225   waitUntilLiveWaiting,
 226   sendRTMPStreamInVideo,
 227   waitUntilLiveEnded,
 228   waitFfmpegUntilError,
 229   sendRTMPStream,
 230   testFfmpegStreamError
 231 }