server/tests/api/redundancy/manage-redundancy.ts

   1 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
   2
   3 import * as chai from 'chai'
   4 import 'mocha'
   5 import {
   6   cleanupTests,
   7   doubleFollow,
   8   flushAndRunMultipleServers,
   9   getLocalIdByUUID,
  10   ServerInfo,
  11   setAccessTokensToServers,
  12   uploadVideo,
  13   uploadVideoAndGetId,
  14   waitUntilLog
  15 } from '../../../../shared/extra-utils'
  16 import { waitJobs } from '../../../../shared/extra-utils/server/jobs'
  17 import { addVideoRedundancy, listVideoRedundancies, removeVideoRedundancy, updateRedundancy } from '@shared/extra-utils/server/redundancy'
  18 import { VideoPrivacy, VideoRedundanciesTarget, VideoRedundancy } from '@shared/models'
  19
  20 const expect = chai.expect
  21
  22 describe('Test manage videos redundancy', function () {
  23   const targets: VideoRedundanciesTarget[] = [ 'my-videos', 'remote-videos' ]
  24
  25   let servers: ServerInfo[]
  26   let video1Server2UUID: string
  27   let video2Server2UUID: string
  28   let redundanciesToRemove: number[] = []
  29
  30   before(async function () {
  31     this.timeout(120000)
  32
  33     const config = {
  34       transcoding: {
  35         hls: {
  36           enabled: true
  37         }
  38       },
  39       redundancy: {
  40         videos: {
  41           check_interval: '1 second',
  42           strategies: [
  43             {
  44               strategy: 'recently-added',
  45               min_lifetime: '1 hour',
  46               size: '10MB',
  47               min_views: 0
  48             }
  49           ]
  50         }
  51       }
  52     }
  53     servers = await flushAndRunMultipleServers(3, config)
  54
  55     // Get the access tokens
  56     await setAccessTokensToServers(servers)
  57
  58     {
  59       const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 1 server 2' })
  60       video1Server2UUID = res.body.video.uuid
  61     }
  62
  63     {
  64       const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 2 server 2' })
  65       video2Server2UUID = res.body.video.uuid
  66     }
  67
  68     await waitJobs(servers)
  69
  70     // Server 1 and server 2 follow each other
  71     await doubleFollow(servers[0], servers[1])
  72     await updateRedundancy(servers[0].url, servers[0].accessToken, servers[1].host, true)
  73
  74     await waitJobs(servers)
  75   })
  76
  77   it('Should not have redundancies on server 3', async function () {
  78     for (const target of targets) {
  79       const res = await listVideoRedundancies({
  80         url: servers[2].url,
  81         accessToken: servers[2].accessToken,
  82         target
  83       })
  84
  85       expect(res.body.total).to.equal(0)
  86       expect(res.body.data).to.have.lengthOf(0)
  87     }
  88   })
  89
  90   it('Should not have "remote-videos" redundancies on server 2', async function () {
  91     this.timeout(120000)
  92
  93     await waitJobs(servers)
  94     await waitUntilLog(servers[0], 'Duplicated ', 10)
  95     await waitJobs(servers)
  96
  97     const res = await listVideoRedundancies({
  98       url: servers[1].url,
  99       accessToken: servers[1].accessToken,
 100       target: 'remote-videos'
 101     })
 102
 103     expect(res.body.total).to.equal(0)
 104     expect(res.body.data).to.have.lengthOf(0)
 105   })
 106
 107   it('Should have "my-videos" redundancies on server 2', async function () {
 108     this.timeout(120000)
 109
 110     const res = await listVideoRedundancies({
 111       url: servers[1].url,
 112       accessToken: servers[1].accessToken,
 113       target: 'my-videos'
 114     })
 115
 116     expect(res.body.total).to.equal(2)
 117
 118     const videos = res.body.data as VideoRedundancy[]
 119     expect(videos).to.have.lengthOf(2)
 120
 121     const videos1 = videos.find(v => v.uuid === video1Server2UUID)
 122     const videos2 = videos.find(v => v.uuid === video2Server2UUID)
 123
 124     expect(videos1.name).to.equal('video 1 server 2')
 125     expect(videos2.name).to.equal('video 2 server 2')
 126
 127     expect(videos1.redundancies.files).to.have.lengthOf(4)
 128     expect(videos1.redundancies.streamingPlaylists).to.have.lengthOf(1)
 129
 130     const redundancies = videos1.redundancies.files.concat(videos1.redundancies.streamingPlaylists)
 131
 132     for (const r of redundancies) {
 133       expect(r.strategy).to.be.null
 134       expect(r.fileUrl).to.exist
 135       expect(r.createdAt).to.exist
 136       expect(r.updatedAt).to.exist
 137       expect(r.expiresOn).to.exist
 138     }
 139   })
 140
 141   it('Should not have "my-videos" redundancies on server 1', async function () {
 142     const res = await listVideoRedundancies({
 143       url: servers[0].url,
 144       accessToken: servers[0].accessToken,
 145       target: 'my-videos'
 146     })
 147
 148     expect(res.body.total).to.equal(0)
 149     expect(res.body.data).to.have.lengthOf(0)
 150   })
 151
 152   it('Should have "remote-videos" redundancies on server 1', async function () {
 153     this.timeout(120000)
 154
 155     const res = await listVideoRedundancies({
 156       url: servers[0].url,
 157       accessToken: servers[0].accessToken,
 158       target: 'remote-videos'
 159     })
 160
 161     expect(res.body.total).to.equal(2)
 162
 163     const videos = res.body.data as VideoRedundancy[]
 164     expect(videos).to.have.lengthOf(2)
 165
 166     const videos1 = videos.find(v => v.uuid === video1Server2UUID)
 167     const videos2 = videos.find(v => v.uuid === video2Server2UUID)
 168
 169     expect(videos1.name).to.equal('video 1 server 2')
 170     expect(videos2.name).to.equal('video 2 server 2')
 171
 172     expect(videos1.redundancies.files).to.have.lengthOf(4)
 173     expect(videos1.redundancies.streamingPlaylists).to.have.lengthOf(1)
 174
 175     const redundancies = videos1.redundancies.files.concat(videos1.redundancies.streamingPlaylists)
 176
 177     for (const r of redundancies) {
 178       expect(r.strategy).to.equal('recently-added')
 179       expect(r.fileUrl).to.exist
 180       expect(r.createdAt).to.exist
 181       expect(r.updatedAt).to.exist
 182       expect(r.expiresOn).to.exist
 183     }
 184   })
 185
 186   it('Should correctly paginate and sort results', async function () {
 187     {
 188       const res = await listVideoRedundancies({
 189         url: servers[0].url,
 190         accessToken: servers[0].accessToken,
 191         target: 'remote-videos',
 192         sort: 'name',
 193         start: 0,
 194         count: 2
 195       })
 196
 197       const videos = res.body.data
 198       expect(videos[0].name).to.equal('video 1 server 2')
 199       expect(videos[1].name).to.equal('video 2 server 2')
 200     }
 201
 202     {
 203       const res = await listVideoRedundancies({
 204         url: servers[0].url,
 205         accessToken: servers[0].accessToken,
 206         target: 'remote-videos',
 207         sort: '-name',
 208         start: 0,
 209         count: 2
 210       })
 211
 212       const videos = res.body.data
 213       expect(videos[0].name).to.equal('video 2 server 2')
 214       expect(videos[1].name).to.equal('video 1 server 2')
 215     }
 216
 217     {
 218       const res = await listVideoRedundancies({
 219         url: servers[0].url,
 220         accessToken: servers[0].accessToken,
 221         target: 'remote-videos',
 222         sort: '-name',
 223         start: 1,
 224         count: 1
 225       })
 226
 227       const videos = res.body.data
 228       expect(videos[0].name).to.equal('video 1 server 2')
 229     }
 230   })
 231
 232   it('Should manually add a redundancy and list it', async function () {
 233     this.timeout(120000)
 234
 235     const uuid = (await uploadVideoAndGetId({ server: servers[1], videoName: 'video 3 server 2', privacy: VideoPrivacy.UNLISTED })).uuid
 236     await waitJobs(servers)
 237     const videoId = await getLocalIdByUUID(servers[0].url, uuid)
 238
 239     await addVideoRedundancy({
 240       url: servers[0].url,
 241       accessToken: servers[0].accessToken,
 242       videoId
 243     })
 244
 245     await waitJobs(servers)
 246     await waitUntilLog(servers[0], 'Duplicated ', 15)
 247     await waitJobs(servers)
 248
 249     {
 250       const res = await listVideoRedundancies({
 251         url: servers[0].url,
 252         accessToken: servers[0].accessToken,
 253         target: 'remote-videos',
 254         sort: '-name',
 255         start: 0,
 256         count: 5
 257       })
 258
 259       const videos = res.body.data
 260       expect(videos[0].name).to.equal('video 3 server 2')
 261
 262       const video = videos[0]
 263       expect(video.redundancies.files).to.have.lengthOf(4)
 264       expect(video.redundancies.streamingPlaylists).to.have.lengthOf(1)
 265
 266       const redundancies = video.redundancies.files.concat(video.redundancies.streamingPlaylists)
 267
 268       for (const r of redundancies) {
 269         redundanciesToRemove.push(r.id)
 270
 271         expect(r.strategy).to.equal('manual')
 272         expect(r.fileUrl).to.exist
 273         expect(r.createdAt).to.exist
 274         expect(r.updatedAt).to.exist
 275         expect(r.expiresOn).to.be.null
 276       }
 277     }
 278
 279     const res = await listVideoRedundancies({
 280       url: servers[1].url,
 281       accessToken: servers[1].accessToken,
 282       target: 'my-videos',
 283       sort: '-name',
 284       start: 0,
 285       count: 5
 286     })
 287
 288     const videos = res.body.data
 289     expect(videos[0].name).to.equal('video 3 server 2')
 290
 291     const video = videos[0]
 292     expect(video.redundancies.files).to.have.lengthOf(4)
 293     expect(video.redundancies.streamingPlaylists).to.have.lengthOf(1)
 294
 295     const redundancies = video.redundancies.files.concat(video.redundancies.streamingPlaylists)
 296
 297     for (const r of redundancies) {
 298       expect(r.strategy).to.be.null
 299       expect(r.fileUrl).to.exist
 300       expect(r.createdAt).to.exist
 301       expect(r.updatedAt).to.exist
 302       expect(r.expiresOn).to.be.null
 303     }
 304   })
 305
 306   it('Should manually remove a redundancy and remove it from the list', async function () {
 307     this.timeout(120000)
 308
 309     for (const redundancyId of redundanciesToRemove) {
 310       await removeVideoRedundancy({
 311         url: servers[0].url,
 312         accessToken: servers[0].accessToken,
 313         redundancyId
 314       })
 315     }
 316
 317     {
 318       const res = await listVideoRedundancies({
 319         url: servers[0].url,
 320         accessToken: servers[0].accessToken,
 321         target: 'remote-videos',
 322         sort: '-name',
 323         start: 0,
 324         count: 5
 325       })
 326
 327       const videos = res.body.data
 328       expect(videos).to.have.lengthOf(2)
 329
 330       expect(videos[0].name).to.equal('video 2 server 2')
 331
 332       redundanciesToRemove = []
 333       const video = videos[0]
 334       expect(video.redundancies.files).to.have.lengthOf(4)
 335       expect(video.redundancies.streamingPlaylists).to.have.lengthOf(1)
 336
 337       const redundancies = video.redundancies.files.concat(video.redundancies.streamingPlaylists)
 338
 339       for (const r of redundancies) {
 340         redundanciesToRemove.push(r.id)
 341       }
 342     }
 343   })
 344
 345   it('Should remove another (auto) redundancy', async function () {
 346     {
 347       for (const redundancyId of redundanciesToRemove) {
 348         await removeVideoRedundancy({
 349           url: servers[0].url,
 350           accessToken: servers[0].accessToken,
 351           redundancyId
 352         })
 353       }
 354
 355       const res = await listVideoRedundancies({
 356         url: servers[0].url,
 357         accessToken: servers[0].accessToken,
 358         target: 'remote-videos',
 359         sort: '-name',
 360         start: 0,
 361         count: 5
 362       })
 363
 364       const videos = res.body.data
 365       expect(videos[0].name).to.equal('video 1 server 2')
 366       expect(videos).to.have.lengthOf(1)
 367     }
 368   })
 369
 370   after(async function () {
 371     await cleanupTests(servers)
 372   })
 373 })