Remove unused class in download modal

[github/Chocobozzz/PeerTube.git] / shared / extra-utils / videos / live.ts

diff --git a/shared/extra-utils/videos/live.ts b/shared/extra-utils/videos/live.ts
index f90dd420d0bdb4243ab931c2dd5798c36e1aa8d7..df73700081cd8be3adbbf18caa9d380fc2788fe7 100644 (file)
--- a/shared/extra-utils/videos/live.ts
+++ b/shared/extra-utils/videos/live.ts
@@ -6,12 +6,13 @@ import { pathExists, readdir } from 'fs-extra'
 import { omit } from 'lodash'
 import { join } from 'path'
 import { LiveVideo, LiveVideoCreate, LiveVideoUpdate, VideoDetails, VideoState } from '@shared/models'
+import { HttpStatusCode } from '../../../shared/core-utils/miscs/http-error-codes'
 import { buildAbsoluteFixturePath, buildServerDirectory, wait } from '../miscs/miscs'
 import { makeGetRequest, makePutBodyRequest, makeUploadRequest } from '../requests/requests'
-import { ServerInfo } from '../server/servers'
+import { ServerInfo, waitUntilLog } from '../server/servers'
 import { getVideoWithToken } from './videos'
 
-function getLive (url: string, token: string, videoId: number | string, statusCodeExpected = 200) {
+function getLive (url: string, token: string, videoId: number | string, statusCodeExpected = HttpStatusCode.OK_200) {
   const path = '/api/v1/videos/live'
 
   return makeGetRequest({
@@ -22,7 +23,13 @@ function getLive (url: string, token: string, videoId: number | string, statusCo
   })
 }
 
-function updateLive (url: string, token: string, videoId: number | string, fields: LiveVideoUpdate, statusCodeExpected = 204) {
+function updateLive (
+  url: string,
+  token: string,
+  videoId: number | string,
+  fields: LiveVideoUpdate,
+  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
+) {
   const path = '/api/v1/videos/live'
 
   return makePutBodyRequest({
@@ -34,7 +41,7 @@ function updateLive (url: string, token: string, videoId: number | string, field
   })
 }
 
-function createLive (url: string, token: string, fields: LiveVideoCreate, statusCodeExpected = 200) {
+function createLive (url: string, token: string, fields: LiveVideoCreate, statusCodeExpected = HttpStatusCode.OK_200) {
   const path = '/api/v1/videos/live'
 
   const attaches: any = {}
@@ -53,15 +60,15 @@ function createLive (url: string, token: string, fields: LiveVideoCreate, status
   })
 }
 
-async function sendRTMPStreamInVideo (url: string, token: string, videoId: number | string) {
+async function sendRTMPStreamInVideo (url: string, token: string, videoId: number | string, fixtureName?: string) {
   const res = await getLive(url, token, videoId)
   const videoLive = res.body as LiveVideo
 
-  return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey)
+  return sendRTMPStream(videoLive.rtmpUrl, videoLive.streamKey, fixtureName)
 }
 
-function sendRTMPStream (rtmpBaseUrl: string, streamKey: string) {
-  const fixture = buildAbsoluteFixturePath('video_short.mp4')
+function sendRTMPStream (rtmpBaseUrl: string, streamKey: string, fixtureName = 'video_short.mp4') {
+  const fixture = buildAbsoluteFixturePath(fixtureName)
 
   const command = ffmpeg(fixture)
   command.inputOption('-stream_loop -1')
@@ -69,6 +76,7 @@ function sendRTMPStream (rtmpBaseUrl: string, streamKey: string) {
   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
@@ -90,7 +98,7 @@ function sendRTMPStream (rtmpBaseUrl: string, streamKey: string) {
 }
 
 function waitFfmpegUntilError (command: ffmpeg.FfmpegCommand, successAfterMS = 10000) {
-  return new Promise((res, rej) => {
+  return new Promise<void>((res, rej) => {
     command.on('error', err => {
       return rej(err)
     })
@@ -111,7 +119,7 @@ async function testFfmpegStreamError (command: ffmpeg.FfmpegCommand, shouldHaveE
   let error: Error
 
   try {
-    await waitFfmpegUntilError(command, 10000)
+    await waitFfmpegUntilError(command, 25000)
   } catch (err) {
     error = err
   }
@@ -128,7 +136,24 @@ async function stopFfmpeg (command: ffmpeg.FfmpegCommand) {
   await wait(500)
 }
 
-async function waitUntilLiveStarts (url: string, token: string, videoId: number | string) {
+function waitUntilLivePublished (url: string, token: string, videoId: number | string) {
+  return waitUntilLiveState(url, token, videoId, VideoState.PUBLISHED)
+}
+
+function waitUntilLiveWaiting (url: string, token: string, videoId: number | string) {
+  return waitUntilLiveState(url, token, videoId, VideoState.WAITING_FOR_LIVE)
+}
+
+function waitUntilLiveEnded (url: string, token: string, videoId: number | string) {
+  return waitUntilLiveState(url, token, videoId, VideoState.LIVE_ENDED)
+}
+
+function waitUntilLiveSegmentGeneration (server: ServerInfo, videoUUID: string, resolutionNum: number, segmentNum: number) {
+  const segmentName = `${resolutionNum}-00000${segmentNum}.ts`
+  return waitUntilLog(server, `${videoUUID}/${segmentName}`, 2, false)
+}
+
+async function waitUntilLiveState (url: string, token: string, videoId: number | string, state: VideoState) {
   let video: VideoDetails
 
   do {
@@ -136,11 +161,22 @@ async function waitUntilLiveStarts (url: string, token: string, videoId: number
     video = res.body
 
     await wait(500)
-  } while (video.state.id === VideoState.WAITING_FOR_LIVE)
+  } while (video.state.id !== state)
+}
+
+async function waitUntilLiveSaved (url: string, token: string, videoId: number | string) {
+  let video: VideoDetails
+
+  do {
+    const res = await getVideoWithToken(url, token, videoId)
+    video = res.body
+
+    await wait(500)
+  } while (video.isLive === true && video.state.id !== VideoState.PUBLISHED)
 }
 
 async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resolutions: number[] = []) {
-  const basePath = buildServerDirectory(server.internalServerNumber, 'streaming-playlists')
+  const basePath = buildServerDirectory(server, 'streaming-playlists')
   const hlsPath = join(basePath, 'hls', videoUUID)
 
   if (resolutions.length === 0) {
@@ -164,17 +200,31 @@ async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resoluti
   expect(files).to.contain('segments-sha256.json')
 }
 
+async function getPlaylistsCount (server: ServerInfo, videoUUID: string) {
+  const basePath = buildServerDirectory(server, 'streaming-playlists')
+  const hlsPath = join(basePath, 'hls', videoUUID)
+
+  const files = await readdir(hlsPath)
+
+  return files.filter(f => f.endsWith('.m3u8')).length
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   getLive,
+  getPlaylistsCount,
+  waitUntilLiveSaved,
+  waitUntilLivePublished,
   updateLive,
-  waitUntilLiveStarts,
   createLive,
   runAndTestFfmpegStreamError,
   checkLiveCleanup,
+  waitUntilLiveSegmentGeneration,
   stopFfmpeg,
+  waitUntilLiveWaiting,
   sendRTMPStreamInVideo,
+  waitUntilLiveEnded,
   waitFfmpegUntilError,
   sendRTMPStream,
   testFfmpegStreamError