X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=shared%2Fextra-utils%2Fvideos%2Flive.ts;h=94f5f5b59a563fd0b96a37a4f984983aaf36c13d;hb=764b1a14fc494f2cfd7ea590d2f07b01df65c7ad;hp=df73700081cd8be3adbbf18caa9d380fc2788fe7;hpb=94d721efdc9a8c2cda612f49506a41adb6a06f1d;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/shared/extra-utils/videos/live.ts b/shared/extra-utils/videos/live.ts
index df7370008..94f5f5b59 100644
--- a/shared/extra-utils/videos/live.ts
+++ b/shared/extra-utils/videos/live.ts
@@ -3,69 +3,9 @@
 import { expect } from 'chai'
 import * as ffmpeg from 'fluent-ffmpeg'
 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, waitUntilLog } from '../server/servers'
-import { getVideoWithToken } from './videos'
-
-function getLive (url: string, token: string, videoId: number | string, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/videos/live'
-
-  return makeGetRequest({
-    url,
-    token,
-    path: path + '/' + videoId,
-    statusCodeExpected
-  })
-}
-
-function updateLive (
-  url: string,
-  token: string,
-  videoId: number | string,
-  fields: LiveVideoUpdate,
-  statusCodeExpected = HttpStatusCode.NO_CONTENT_204
-) {
-  const path = '/api/v1/videos/live'
-
-  return makePutBodyRequest({
-    url,
-    token,
-    path: path + '/' + videoId,
-    fields,
-    statusCodeExpected
-  })
-}
-
-function createLive (url: string, token: string, fields: LiveVideoCreate, statusCodeExpected = HttpStatusCode.OK_200) {
-  const path = '/api/v1/videos/live'
-
-  const attaches: any = {}
-  if (fields.thumbnailfile) attaches.thumbnailfile = fields.thumbnailfile
-  if (fields.previewfile) attaches.previewfile = fields.previewfile
-
-  const updatedFields = omit(fields, 'thumbnailfile', 'previewfile')
-
-  return makeUploadRequest({
-    url,
-    path,
-    token,
-    attaches,
-    fields: updatedFields,
-    statusCodeExpected
-  })
-}
-
-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, fixtureName)
-}
+import { buildAbsoluteFixturePath, wait } from '../miscs'
+import { PeerTubeServer } from '../server/server'
 
 function sendRTMPStream (rtmpBaseUrl: string, streamKey: string, fixtureName = 'video_short.mp4') {
   const fixture = buildAbsoluteFixturePath(fixtureName)
@@ -109,17 +49,11 @@ function waitFfmpegUntilError (command: ffmpeg.FfmpegCommand, successAfterMS = 1
   })
 }
 
-async function runAndTestFfmpegStreamError (url: string, token: string, videoId: number | string, shouldHaveError: boolean) {
-  const command = await sendRTMPStreamInVideo(url, token, videoId)
-
-  return testFfmpegStreamError(command, shouldHaveError)
-}
-
 async function testFfmpegStreamError (command: ffmpeg.FfmpegCommand, shouldHaveError: boolean) {
   let error: Error
 
   try {
-    await waitFfmpegUntilError(command, 25000)
+    await waitFfmpegUntilError(command, 35000)
   } catch (err) {
     error = err
   }
@@ -136,47 +70,14 @@ async function stopFfmpeg (command: ffmpeg.FfmpegCommand) {
   await wait(500)
 }
 
-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 {
-    const res = await getVideoWithToken(url, token, videoId)
-    video = res.body
-
-    await wait(500)
-  } 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 waitUntilLivePublishedOnAllServers (servers: PeerTubeServer[], videoId: string) {
+  for (const server of servers) {
+    await server.live.waitUntilPublished({ videoId })
+  }
 }
 
-async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resolutions: number[] = []) {
-  const basePath = buildServerDirectory(server, 'streaming-playlists')
+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) {
@@ -192,40 +93,25 @@ async function checkLiveCleanup (server: ServerInfo, videoUUID: string, resoluti
   expect(files).to.have.lengthOf(resolutions.length * 2 + 2)
 
   for (const resolution of resolutions) {
-    expect(files).to.contain(`${videoUUID}-${resolution}-fragmented.mp4`)
-    expect(files).to.contain(`${resolution}.m3u8`)
-  }
+    const fragmentedFile = files.find(f => f.endsWith(`-${resolution}-fragmented.mp4`))
+    expect(fragmentedFile).to.exist
 
-  expect(files).to.contain('master.m3u8')
-  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 playlistFile = files.find(f => f.endsWith(`${resolution}.m3u8`))
+    expect(playlistFile).to.exist
+  }
 
-  const files = await readdir(hlsPath)
+  const masterPlaylistFile = files.find(f => f.endsWith('-master.m3u8'))
+  expect(masterPlaylistFile).to.exist
 
-  return files.filter(f => f.endsWith('.m3u8')).length
+  const shaFile = files.find(f => f.endsWith('-segments-sha256.json'))
+  expect(shaFile).to.exist
 }
 
-// ---------------------------------------------------------------------------
-
 export {
-  getLive,
-  getPlaylistsCount,
-  waitUntilLiveSaved,
-  waitUntilLivePublished,
-  updateLive,
-  createLive,
-  runAndTestFfmpegStreamError,
-  checkLiveCleanup,
-  waitUntilLiveSegmentGeneration,
-  stopFfmpeg,
-  waitUntilLiveWaiting,
-  sendRTMPStreamInVideo,
-  waitUntilLiveEnded,
-  waitFfmpegUntilError,
   sendRTMPStream,
-  testFfmpegStreamError
+  waitFfmpegUntilError,
+  testFfmpegStreamError,
+  stopFfmpeg,
+  waitUntilLivePublishedOnAllServers,
+  checkLiveCleanupAfterSave
 }