Add ability to disable webtorrent

In favour of HLS

4 files changed, 156 insertions, 69 deletions

diff --git a/server/tests/api/check-params/config.ts b/server/tests/api/check-params/config.ts
index 9435bb1e8..3c558d4ea 100644
--- a/server/tests/api/check-params/config.ts
+++ b/server/tests/api/check-params/config.ts
@@ -92,6 +92,9 @@ describe('Test config API validators', function () {
         '1080p': false,
         '2160p': false
       },
+      webtorrent: {
+        enabled: true
+      },
       hls: {
         enabled: false
       }
@@ -235,6 +238,27 @@ describe('Test config API validators', function () {
       })
     })
 
+    it('Should fail with a disabled webtorrent & hls transcoding', async function () {
+      const newUpdateParams = immutableAssign(updateParams, {
+        transcoding: {
+          hls: {
+            enabled: false
+          },
+          webtorrent: {
+            enabled: false
+          }
+        }
+      })
+
+      await makePutBodyRequest({
+        url: server.url,
+        path,
+        fields: newUpdateParams,
+        token: server.accessToken,
+        statusCodeExpected: 400
+      })
+    })
+
     it('Should success with the correct parameters', async function () {
       await makePutBodyRequest({
         url: server.url,
diff --git a/server/tests/api/server/config.ts b/server/tests/api/server/config.ts
index 97cc99eea..a494858b3 100644
--- a/server/tests/api/server/config.ts
+++ b/server/tests/api/server/config.ts
@@ -72,6 +72,7 @@ function checkInitialConfig (server: ServerInfo, data: CustomConfig) {
   expect(data.transcoding.resolutions['720p']).to.be.true
   expect(data.transcoding.resolutions['1080p']).to.be.true
   expect(data.transcoding.resolutions['2160p']).to.be.true
+  expect(data.transcoding.webtorrent.enabled).to.be.true
   expect(data.transcoding.hls.enabled).to.be.true
 
   expect(data.import.videos.http.enabled).to.be.true
@@ -140,6 +141,7 @@ function checkUpdatedConfig (data: CustomConfig) {
   expect(data.transcoding.resolutions['1080p']).to.be.false
   expect(data.transcoding.resolutions['2160p']).to.be.false
   expect(data.transcoding.hls.enabled).to.be.false
+  expect(data.transcoding.webtorrent.enabled).to.be.true
 
   expect(data.import.videos.http.enabled).to.be.false
   expect(data.import.videos.torrent.enabled).to.be.false
@@ -279,6 +281,9 @@ describe('Test config', function () {
           '1080p': false,
           '2160p': false
         },
+        webtorrent: {
+          enabled: true
+        },
         hls: {
           enabled: false
         }
diff --git a/server/tests/api/videos/video-hls.ts b/server/tests/api/videos/video-hls.ts
index 39178bb1a..289209177 100644
--- a/server/tests/api/videos/video-hls.ts
+++ b/server/tests/api/videos/video-hls.ts
@@ -10,13 +10,13 @@ import {
   doubleFollow,
   flushAndRunMultipleServers,
   getPlaylist,
-  getVideo,
+  getVideo, makeGetRequest, makeRawRequest,
   removeVideo,
   ServerInfo,
-  setAccessTokensToServers,
+  setAccessTokensToServers, updateCustomSubConfig,
   updateVideo,
   uploadVideo,
-  waitJobs
+  waitJobs, webtorrentAdd
 } from '../../../../shared/extra-utils'
 import { VideoDetails } from '../../../../shared/models/videos'
 import { VideoStreamingPlaylistType } from '../../../../shared/models/videos/video-streaming-playlist.type'
@@ -25,20 +25,45 @@ import { DEFAULT_AUDIO_RESOLUTION } from '../../../initializers/constants'
 
 const expect = chai.expect
 
-async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, resolutions = [ 240, 360, 480, 720 ]) {
+async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, hlsOnly: boolean, resolutions = [ 240, 360, 480, 720 ]) {
   for (const server of servers) {
-    const res = await getVideo(server.url, videoUUID)
-    const videoDetails: VideoDetails = res.body
+    const resVideoDetails = await getVideo(server.url, videoUUID)
+    const videoDetails: VideoDetails = resVideoDetails.body
+    const baseUrl = `http://${videoDetails.account.host}`
 
     expect(videoDetails.streamingPlaylists).to.have.lengthOf(1)
 
     const hlsPlaylist = videoDetails.streamingPlaylists.find(p => p.type === VideoStreamingPlaylistType.HLS)
     expect(hlsPlaylist).to.not.be.undefined
 
+    const hlsFiles = hlsPlaylist.files
+    expect(hlsFiles).to.have.lengthOf(resolutions.length)
+
+    if (hlsOnly) expect(videoDetails.files).to.have.lengthOf(0)
+    else expect(videoDetails.files).to.have.lengthOf(resolutions.length)
+
+    for (const resolution of resolutions) {
+      const file = hlsFiles.find(f => f.resolution.id === resolution)
+      expect(file).to.not.be.undefined
+
+      expect(file.magnetUri).to.have.lengthOf.above(2)
+      expect(file.torrentUrl).to.equal(`${baseUrl}/static/torrents/${videoDetails.uuid}-${file.resolution.id}-hls.torrent`)
+      expect(file.fileUrl).to.equal(`${baseUrl}/static/streaming-playlists/hls/${videoDetails.uuid}/${videoDetails.uuid}-${file.resolution.id}-fragmented.mp4`)
+      expect(file.resolution.label).to.equal(resolution + 'p')
+
+      await makeRawRequest(file.torrentUrl, 200)
+      await makeRawRequest(file.fileUrl, 200)
+
+      const torrent = await webtorrentAdd(file.magnetUri, true)
+      expect(torrent.files).to.be.an('array')
+      expect(torrent.files.length).to.equal(1)
+      expect(torrent.files[0].path).to.exist.and.to.not.equal('')
+    }
+
     {
-      const res2 = await getPlaylist(hlsPlaylist.playlistUrl)
+      const res = await getPlaylist(hlsPlaylist.playlistUrl)
 
-      const masterPlaylist = res2.text
+      const masterPlaylist = res.text
 
       for (const resolution of resolutions) {
         expect(masterPlaylist).to.match(new RegExp('#EXT-X-STREAM-INF:BANDWIDTH=\\d+,RESOLUTION=\\d+x' + resolution + ',FRAME-RATE=\\d+'))
@@ -48,18 +73,18 @@ async function checkHlsPlaylist (servers: ServerInfo[], videoUUID: string, resol
 
     {
       for (const resolution of resolutions) {
-        const res2 = await getPlaylist(`http://localhost:${servers[0].port}/static/streaming-playlists/hls/${videoUUID}/${resolution}.m3u8`)
+        const res = await getPlaylist(`${baseUrl}/static/streaming-playlists/hls/${videoUUID}/${resolution}.m3u8`)
 
-        const subPlaylist = res2.text
+        const subPlaylist = res.text
         expect(subPlaylist).to.contain(`${videoUUID}-${resolution}-fragmented.mp4`)
       }
     }
 
     {
-      const baseUrl = 'http://localhost:' + servers[0].port + '/static/streaming-playlists/hls'
+      const baseUrlAndPath = baseUrl + '/static/streaming-playlists/hls'
 
       for (const resolution of resolutions) {
-        await checkSegmentHash(baseUrl, baseUrl, videoUUID, resolution, hlsPlaylist)
+        await checkSegmentHash(baseUrlAndPath, baseUrlAndPath, videoUUID, resolution, hlsPlaylist)
       }
     }
   }
@@ -70,84 +95,118 @@ describe('Test HLS videos', function () {
   let videoUUID = ''
   let videoAudioUUID = ''
 
-  before(async function () {
-    this.timeout(120000)
+  function runTestSuite (hlsOnly: boolean) {
+    it('Should upload a video and transcode it to HLS', async function () {
+      this.timeout(120000)
 
-    const configOverride = {
-      transcoding: {
-        enabled: true,
-        allow_audio_files: true,
-        hls: {
-          enabled: true
-        }
-      }
-    }
-    servers = await flushAndRunMultipleServers(2, configOverride)
+      const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, { name: 'video 1', fixture: 'video_short.webm' })
+      videoUUID = res.body.video.uuid
 
-    // Get the access tokens
-    await setAccessTokensToServers(servers)
+      await waitJobs(servers)
 
-    // Server 1 and server 2 follow each other
-    await doubleFollow(servers[0], servers[1])
-  })
+      await checkHlsPlaylist(servers, videoUUID, hlsOnly)
+    })
 
-  it('Should upload a video and transcode it to HLS', async function () {
-    this.timeout(120000)
+    it('Should upload an audio file and transcode it to HLS', async function () {
+      this.timeout(120000)
 
-    const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, { name: 'video 1', fixture: 'video_short.webm' })
-    videoUUID = res.body.video.uuid
+      const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, { name: 'video audio', fixture: 'sample.ogg' })
+      videoAudioUUID = res.body.video.uuid
 
-    await waitJobs(servers)
+      await waitJobs(servers)
 
-    await checkHlsPlaylist(servers, videoUUID)
-  })
+      await checkHlsPlaylist(servers, videoAudioUUID, hlsOnly, [ DEFAULT_AUDIO_RESOLUTION ])
+    })
 
-  it('Should upload an audio file and transcode it to HLS', async function () {
-    this.timeout(120000)
+    it('Should update the video', async function () {
+      this.timeout(10000)
 
-    const res = await uploadVideo(servers[ 0 ].url, servers[ 0 ].accessToken, { name: 'video audio', fixture: 'sample.ogg' })
-    videoAudioUUID = res.body.video.uuid
+      await updateVideo(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID, { name: 'video 1 updated' })
 
-    await waitJobs(servers)
+      await waitJobs(servers)
 
-    await checkHlsPlaylist(servers, videoAudioUUID, [ DEFAULT_AUDIO_RESOLUTION ])
-  })
+      await checkHlsPlaylist(servers, videoUUID, hlsOnly)
+    })
 
-  it('Should update the video', async function () {
-    this.timeout(10000)
+    it('Should delete videos', async function () {
+      this.timeout(10000)
 
-    await updateVideo(servers[0].url, servers[0].accessToken, videoUUID, { name: 'video 1 updated' })
+      await removeVideo(servers[ 0 ].url, servers[ 0 ].accessToken, videoUUID)
+      await removeVideo(servers[ 0 ].url, servers[ 0 ].accessToken, videoAudioUUID)
 
-    await waitJobs(servers)
+      await waitJobs(servers)
 
-    await checkHlsPlaylist(servers, videoUUID)
-  })
+      for (const server of servers) {
+        await getVideo(server.url, videoUUID, 404)
+        await getVideo(server.url, videoAudioUUID, 404)
+      }
+    })
 
-  it('Should delete videos', async function () {
-    this.timeout(10000)
+    it('Should have the playlists/segment deleted from the disk', async function () {
+      for (const server of servers) {
+        await checkDirectoryIsEmpty(server, 'videos')
+        await checkDirectoryIsEmpty(server, join('streaming-playlists', 'hls'))
+      }
+    })
 
-    await removeVideo(servers[0].url, servers[0].accessToken, videoUUID)
-    await removeVideo(servers[0].url, servers[0].accessToken, videoAudioUUID)
+    it('Should have an empty tmp directory', async function () {
+      for (const server of servers) {
+        await checkTmpIsEmpty(server)
+      }
+    })
+  }
 
-    await waitJobs(servers)
+  before(async function () {
+    this.timeout(120000)
 
-    for (const server of servers) {
-      await getVideo(server.url, videoUUID, 404)
-      await getVideo(server.url, videoAudioUUID, 404)
+    const configOverride = {
+      transcoding: {
+        enabled: true,
+        allow_audio_files: true,
+        hls: {
+          enabled: true
+        }
+      }
     }
+    servers = await flushAndRunMultipleServers(2, configOverride)
+
+    // Get the access tokens
+    await setAccessTokensToServers(servers)
+
+    // Server 1 and server 2 follow each other
+    await doubleFollow(servers[0], servers[1])
   })
 
-  it('Should have the playlists/segment deleted from the disk', async function () {
-    for (const server of servers) {
-      await checkDirectoryIsEmpty(server, 'videos')
-      await checkDirectoryIsEmpty(server, join('streaming-playlists', 'hls'))
-    }
+  describe('With WebTorrent & HLS enabled', function () {
+    runTestSuite(false)
   })
 
-  it('Should have an empty tmp directory', async function () {
-    for (const server of servers) {
-      await checkTmpIsEmpty(server)
-    }
+  describe('With only HLS enabled', function () {
+
+    before(async function () {
+      await updateCustomSubConfig(servers[0].url, servers[0].accessToken, {
+        transcoding: {
+          enabled: true,
+          allowAudioFiles: true,
+          resolutions: {
+            '240p': true,
+            '360p': true,
+            '480p': true,
+            '720p': true,
+            '1080p': true,
+            '2160p': true
+          },
+          hls: {
+            enabled: true
+          },
+          webtorrent: {
+            enabled: false
+          }
+        }
+      })
+    })
+
+    runTestSuite(true)
   })
 
   after(async function () {
diff --git a/server/tests/cli/create-import-video-file-job.ts b/server/tests/cli/create-import-video-file-job.ts
index 0d378c1aa..aca3216bb 100644
--- a/server/tests/cli/create-import-video-file-job.ts
+++ b/server/tests/cli/create-import-video-file-job.ts
@@ -2,22 +2,21 @@
 
 import 'mocha'
 import * as chai from 'chai'
-import { VideoDetails, VideoFile } from '../../../shared/models/videos'
+import { VideoDetails } from '../../../shared/models/videos'
 import {
   cleanupTests,
   doubleFollow,
   execCLI,
   flushAndRunMultipleServers,
-  flushTests,
   getEnvCli,
   getVideo,
   getVideosList,
-  killallServers,
   ServerInfo,
   setAccessTokensToServers,
   uploadVideo
 } from '../../../shared/extra-utils'
 import { waitJobs } from '../../../shared/extra-utils/server/jobs'
+import { VideoFile } from '@shared/models/videos/video-file.model'
 
 const expect = chai.expect