Implement video transcoding on server side

4 files changed, 70 insertions, 34 deletions

diff --git a/server/tests/api/multiple-pods.ts b/server/tests/api/multiple-pods.ts
index 7117ab290..9860935e5 100644
--- a/server/tests/api/multiple-pods.ts
+++ b/server/tests/api/multiple-pods.ts
@@ -129,7 +129,7 @@ describe('Test multiple pods', function () {
     })
 
     it('Should upload the video on pod 2 and propagate on each pod', async function () {
-      this.timeout(60000)
+      this.timeout(120000)
 
       const videoAttributes = {
         name: 'my super name for pod 2',
@@ -143,12 +143,12 @@ describe('Test multiple pods', function () {
       }
       await uploadVideo(servers[1].url, servers[1].accessToken, videoAttributes)
 
-      // Transcoding, so wait more that 22 seconds
-      await wait(42000)
+      // Transcoding, so wait more than 22000
+      await wait(60000)
 
       // All pods should have this video
       for (const server of servers) {
-        let baseMagnet = null
+        let baseMagnet = {}
 
         const res = await getVideosList(server.url)
 
@@ -172,28 +172,51 @@ describe('Test multiple pods', function () {
         expect(dateIsValid(video.updatedAt)).to.be.true
         expect(video.author).to.equal('root')
 
-        expect(video.files).to.have.lengthOf(1)
+        expect(video.files).to.have.lengthOf(5)
 
-        const file = video.files[0]
-        const magnetUri = file.magnetUri
-        expect(file.magnetUri).to.have.lengthOf.above(2)
-        expect(file.resolution).to.equal(0)
-        expect(file.resolutionLabel).to.equal('original')
-        expect(file.size).to.equal(942961)
+        // Check common attributes
+        for (const file of video.files) {
+          expect(file.magnetUri).to.have.lengthOf.above(2)
 
-        if (server.url !== 'http://localhost:9002') {
-          expect(video.isLocal).to.be.false
-        } else {
-          expect(video.isLocal).to.be.true
-        }
+          if (server.url !== 'http://localhost:9002') {
+            expect(video.isLocal).to.be.false
+          } else {
+            expect(video.isLocal).to.be.true
+          }
 
-        // All pods should have the same magnet Uri
-        if (baseMagnet === null) {
-          baseMagnet = magnetUri
-        } else {
-          expect(baseMagnet).to.equal(magnetUri)
+          // All pods should have the same magnet Uri
+          if (baseMagnet[file.resolution] === undefined) {
+            baseMagnet[file.resolution] = file.magnet
+          } else {
+            expect(baseMagnet[file.resolution]).to.equal(file.magnet)
+          }
         }
 
+        const originalFile = video.files.find(f => f.resolution === 0)
+        expect(originalFile).not.to.be.undefined
+        expect(originalFile.resolutionLabel).to.equal('original')
+        expect(originalFile.size).to.equal(711327)
+
+        const file240p = video.files.find(f => f.resolution === 1)
+        expect(file240p).not.to.be.undefined
+        expect(file240p.resolutionLabel).to.equal('240p')
+        expect(file240p.size).to.equal(139953)
+
+        const file360p = video.files.find(f => f.resolution === 2)
+        expect(file360p).not.to.be.undefined
+        expect(file360p.resolutionLabel).to.equal('360p')
+        expect(file360p.size).to.equal(169926)
+
+        const file480p = video.files.find(f => f.resolution === 3)
+        expect(file480p).not.to.be.undefined
+        expect(file480p.resolutionLabel).to.equal('480p')
+        expect(file480p.size).to.equal(206758)
+
+        const file720p = video.files.find(f => f.resolution === 4)
+        expect(file720p).not.to.be.undefined
+        expect(file720p.resolutionLabel).to.equal('720p')
+        expect(file720p.size).to.equal(314913)
+
         const test = await testVideoImage(server.url, 'video_short2.webm', video.thumbnailPath)
         expect(test).to.equal(true)
       }
diff --git a/server/tests/api/video-transcoder.ts b/server/tests/api/video-transcoder.ts
index c6d4c61f5..b5d84d9e7 100644
--- a/server/tests/api/video-transcoder.ts
+++ b/server/tests/api/video-transcoder.ts
@@ -42,6 +42,8 @@ describe('Test video transcoding', function () {
 
     const res = await getVideosList(servers[0].url)
     const video = res.body.data[0]
+    expect(video.files).to.have.lengthOf(1)
+
     const magnetUri = video.files[0].magnetUri
     expect(magnetUri).to.match(/\.webm/)
 
@@ -66,6 +68,8 @@ describe('Test video transcoding', function () {
     const res = await getVideosList(servers[1].url)
 
     const video = res.body.data[0]
+    expect(video.files).to.have.lengthOf(5)
+
     const magnetUri = video.files[0].magnetUri
     expect(magnetUri).to.match(/\.mp4/)
 
diff --git a/server/tests/cli/update-host.ts b/server/tests/cli/update-host.ts
index 644b3807e..e31a84156 100644
--- a/server/tests/cli/update-host.ts
+++ b/server/tests/cli/update-host.ts
@@ -12,14 +12,15 @@ import {
   runServer,
   ServerInfo,
   setAccessTokensToServers,
-  uploadVideo
+  uploadVideo,
+  wait
 } from '../utils'
 
 describe('Test update host scripts', function () {
   let server: ServerInfo
 
   before(async function () {
-    this.timeout(30000)
+    this.timeout(60000)
 
     await flushTests()
 
@@ -28,36 +29,43 @@ describe('Test update host scripts', function () {
         port: 9256
       }
     }
-    server = await runServer(1, overrideConfig)
+    // Run server 2 to have transcoding enabled
+    server = await runServer(2, overrideConfig)
     await setAccessTokensToServers([ server ])
 
     // Upload two videos for our needs
     const videoAttributes = {}
     await uploadVideo(server.url, server.accessToken, videoAttributes)
     await uploadVideo(server.url, server.accessToken, videoAttributes)
+    await wait(30000)
   })
 
   it('Should update torrent hosts', async function () {
     this.timeout(30000)
 
     killallServers([ server ])
-    server = await runServer(1)
+    // Run server with standard configuration
+    server = await runServer(2)
 
     const env = getEnvCli(server)
     await execCLI(`${env} npm run update-host`)
 
     const res = await getVideosList(server.url)
     const videos = res.body.data
+    expect(videos).to.have.lengthOf(2)
 
-    expect(videos[0].files[0].magnetUri).to.contain('localhost%3A9001%2Ftracker%2Fsocket')
-    expect(videos[0].files[0].magnetUri).to.contain('localhost%3A9001%2Fstatic%2Fwebseed%2F')
+    for (const video of videos) {
+      expect(video.files).to.have.lengthOf(5)
 
-    expect(videos[1].files[0].magnetUri).to.contain('localhost%3A9001%2Ftracker%2Fsocket')
-    expect(videos[1].files[0].magnetUri).to.contain('localhost%3A9001%2Fstatic%2Fwebseed%2F')
+      for (const file of video.files) {
+        expect(file.magnetUri).to.contain('localhost%3A9002%2Ftracker%2Fsocket')
+        expect(file.magnetUri).to.contain('localhost%3A9002%2Fstatic%2Fwebseed%2F')
 
-    const torrent = await parseTorrentVideo(server, videos[0].uuid)
-    expect(torrent.announce[0]).to.equal('ws://localhost:9001/tracker/socket')
-    expect(torrent.urlList[0]).to.contain('http://localhost:9001/static/webseed')
+        const torrent = await parseTorrentVideo(server, video.uuid, file.resolutionLabel)
+        expect(torrent.announce[0]).to.equal('ws://localhost:9002/tracker/socket')
+        expect(torrent.urlList[0]).to.contain('http://localhost:9002/static/webseed')
+      }
+    }
   })
 
   after(async function () {
diff --git a/server/tests/utils/videos.ts b/server/tests/utils/videos.ts
index 0de506cd9..7f8bd39c0 100644
--- a/server/tests/utils/videos.ts
+++ b/server/tests/utils/videos.ts
@@ -238,9 +238,10 @@ function rateVideo (url: string, accessToken: string, id: number, rating: string
           .expect(specialStatus)
 }
 
-function parseTorrentVideo (server: ServerInfo, videoUUID: string) {
+function parseTorrentVideo (server: ServerInfo, videoUUID: string, resolutionLabel: string) {
   return new Promise<any>((res, rej) => {
-    const torrentPath = join(__dirname, '..', '..', '..', 'test' + server.serverNumber, 'torrents', videoUUID + '.torrent')
+    const torrentName = videoUUID + '-' + resolutionLabel + '.torrent'
+    const torrentPath = join(__dirname, '..', '..', '..', 'test' + server.serverNumber, 'torrents', torrentName)
     readFile(torrentPath, (err, data) => {
       if (err) return rej(err)