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 { buildAbsoluteFixturePath, buildServerDirectory, wait } from '../miscs/miscs'
  10 import { makeGetRequest, makePutBodyRequest, makeUploadRequest } from '../requests/requests'
  11 import { ServerInfo } from '../server/servers'
  12 import { getVideoWithToken } from './videos'
  13
  14 function getLive (url: string, token: string, videoId: number | string, statusCodeExpected = 200) {
  15   const path = '/api/v1/videos/live'
  16
  17   return makeGetRequest({
  18     url,
  19     token,
  20     path: path + '/' + videoId,
  21     statusCodeExpected
  22   })
  23 }
  24
  25 function updateLive (url: string, token: string, videoId: number | string, fields: LiveVideoUpdate, statusCodeExpected = 204) {
  26   const path = '/api/v1/videos/live'
  27
  28   return makePutBodyRequest({
  29     url,
  30     token,
  31     path: path + '/' + videoId,
  32     fields,
  33     statusCodeExpected
  34   })
  35 }
  36
  37 function createLive (url: string, token: string, fields: LiveVideoCreate, statusCodeExpected = 200) {
  38   const path = '/api/v1/videos/live'
  39
  40   const attaches: any = {}
  41   if (fields.thumbnailfile) attaches.thumbnailfile = fields.thumbnailfile
  42   if (fields.previewfile) attaches.previewfile = fields.previewfile
  43
  44   const updatedFields = omit(fields, 'thumbnailfile', 'previewfile')
  45
  46   return makeUploadRequest({
  47     url,
  48     path,
  49     token,
  50     attaches,
  51     fields: updatedFields,
  52     statusCodeExpected
  53   })
  54 }
  55
  56 async function sendRTMPStreamInVideo (url: string, token: string, videoId: number | string) {
  57   const res = await getLive(url, token, videoId)
  58   const videoLive = res.body as LiveVideo
  59
  60   return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey)
  61 }
  62
  63 function sendRTMPStream (rtmpBaseUrl: string, streamKey: string) {
  64   const fixture = buildAbsoluteFixturePath('video_short.mp4')
  65
  66   const command = ffmpeg(fixture)
  67   command.inputOption('-stream_loop -1')
  68   command.inputOption('-re')
  69   command.outputOption('-c:v libx264')
  70   command.outputOption('-g 50')
  71   command.outputOption('-keyint_min 2')
  72   command.outputOption('-f flv')
  73
  74   const rtmpUrl = rtmpBaseUrl + '/' + streamKey
  75   command.output(rtmpUrl)
  76
  77   command.on('error', err => {
  78     if (err?.message?.includes('Exiting normally')) return
  79
  80     if (process.env.DEBUG) console.error(err)
  81   })
  82
  83   if (process.env.DEBUG) {
  84     command.on('stderr', data => console.log(data))
  85   }
  86
  87   command.run()
  88
  89   return command
  90 }
  91
  92 function waitFfmpegUntilError (command: ffmpeg.FfmpegCommand, successAfterMS = 10000) {
  93   return new Promise((res, rej) => {
  94     command.on('error', err => {
  95       return rej(err)
  96     })
  97
  98     setTimeout(() => {
  99       res()
 100     }, successAfterMS)
 101   })
 102 }
 103
 104 async function runAndTestFfmpegStreamError (url: string, token: string, videoId: number | string, shouldHaveError: boolean) {
 105   const command = await sendRTMPStreamInVideo(url, token, videoId)
 106
 107   return testFfmpegStreamError(command, shouldHaveError)
 108 }
 109
 110 async function testFfmpegStreamError (command: ffmpeg.FfmpegCommand, shouldHaveError: boolean) {
 111   let error: Error
 112
 113   try {
 114     await waitFfmpegUntilError(command, 15000)
 115   } catch (err) {
 116     error = err
 117   }
 118
 119   await stopFfmpeg(command)
 120
 121   if (shouldHaveError && !error) throw new Error('Ffmpeg did not have an error')
 122   if (!shouldHaveError && error) throw error
 123 }
 124
 125 async function stopFfmpeg (command: ffmpeg.FfmpegCommand) {
 126   command.kill('SIGINT')
 127
 128   await wait(500)
 129 }
 130
 131 async function waitUntilLiveStarts (url: string, token: string, videoId: number | string) {
 132   let video: VideoDetails
 133
 134   do {
 135     const res = await getVideoWithToken(url, token, videoId)
 136     video = res.body
 137
 138     await wait(500)
 139   } while (video.state.id === VideoState.WAITING_FOR_LIVE)
 140 }
 141
 142 async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resolutions: number[] = []) {
 143   const basePath = buildServerDirectory(server.internalServerNumber, 'streaming-playlists')
 144   const hlsPath = join(basePath, 'hls', videoUUID)
 145
 146   if (resolutions.length === 0) {
 147     const result = await pathExists(hlsPath)
 148     expect(result).to.be.false
 149
 150     return
 151   }
 152
 153   const files = await readdir(hlsPath)
 154
 155   // fragmented file and playlist per resolution + master playlist + segments sha256 json file
 156   expect(files).to.have.lengthOf(resolutions.length * 2 + 2)
 157
 158   for (const resolution of resolutions) {
 159     expect(files).to.contain(`${videoUUID}-${resolution}-fragmented.mp4`)
 160     expect(files).to.contain(`${resolution}.m3u8`)
 161   }
 162
 163   expect(files).to.contain('master.m3u8')
 164   expect(files).to.contain('segments-sha256.json')
 165 }
 166
 167 // ---------------------------------------------------------------------------
 168
 169 export {
 170   getLive,
 171   updateLive,
 172   waitUntilLiveStarts,
 173   createLive,
 174   runAndTestFfmpegStreamError,
 175   checkLiveCleanup,
 176   stopFfmpeg,
 177   sendRTMPStreamInVideo,
 178   waitFfmpegUntilError,
 179   sendRTMPStream,
 180   testFfmpegStreamError
 181 }