X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Ftests%2Fapi%2Fredundancy%2Fredundancy.ts;h=00a5e86ccb85ba0621980b47c621326e8e7d9c1e;hb=7926c5f9b3ffcabb1ffb0dcfa5e48b8e0b88fbc0;hp=1960854b654136e5d5b40818c7aa5490a40f95a7;hpb=be0f59b4eec3c2c4dcd151e2b174be39dff1568e;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/tests/api/redundancy/redundancy.ts b/server/tests/api/redundancy/redundancy.ts index 1960854b6..00a5e86cc 100644 --- a/server/tests/api/redundancy/redundancy.ts +++ b/server/tests/api/redundancy/redundancy.ts @@ -1,38 +1,39 @@ -/* tslint:disable:no-unused-expression */ +/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */ -import * as chai from 'chai' import 'mocha' -import { VideoDetails } from '../../../../shared/models/videos' +import * as chai from 'chai' +import { readdir } from 'fs-extra' +import * as magnetUtil from 'magnet-uri' +import { join } from 'path' +import { HttpStatusCode } from '@shared/core-utils' import { + checkSegmentHash, + checkVideoFilesWereRemoved, + cleanupTests, doubleFollow, flushAndRunMultipleServers, - getFollowingListPaginationAndSort, getVideo, - immutableAssign, - killallServers, makeGetRequest, + getVideoWithToken, + killallServers, + makeGetRequest, + removeVideo, + reRunServer, root, ServerInfo, - setAccessTokensToServers, unfollow, + setAccessTokensToServers, + updateVideo, uploadVideo, viewVideo, wait, - waitUntilLog, - checkVideoFilesWereRemoved, removeVideo -} from '../../utils' -import { waitJobs } from '../../utils/server/jobs' -import * as magnetUtil from 'magnet-uri' -import { updateRedundancy } from '../../utils/server/redundancy' -import { ActorFollow } from '../../../../shared/models/actors' -import { readdir } from 'fs-extra' -import { join } from 'path' -import { VideoRedundancyStrategy } from '../../../../shared/models/redundancy' -import { getStats } from '../../utils/server/stats' -import { ServerStats } from '../../../../shared/models/server/server-stats.model' + waitJobs +} from '@shared/extra-utils' +import { VideoDetails, VideoPrivacy, VideoRedundancyStrategy, VideoRedundancyStrategyWithManual } from '@shared/models' const expect = chai.expect let servers: ServerInfo[] = [] let video1Server2UUID: string +let video1Server2Id: number function checkMagnetWebseeds (file: { magnetUri: string, resolution: { id: number } }, baseWebseeds: string[], server: ServerInfo) { const parsed = magnetUtil.decode(file.magnetUri) @@ -45,98 +46,87 @@ function checkMagnetWebseeds (file: { magnetUri: string, resolution: { id: numbe expect(parsed.urlList).to.have.lengthOf(baseWebseeds.length) } -async function runServers (strategy: VideoRedundancyStrategy, additionalParams: any = {}) { +async function flushAndRunServers (strategy: VideoRedundancyStrategy | null, additionalParams: any = {}, withWebtorrent = true) { + const strategies: any[] = [] + + if (strategy !== null) { + strategies.push( + { + min_lifetime: '1 hour', + strategy: strategy, + size: '400KB', + + ...additionalParams + } + ) + } + const config = { + transcoding: { + webtorrent: { + enabled: withWebtorrent + }, + hls: { + enabled: true + } + }, redundancy: { videos: { check_interval: '5 seconds', - strategies: [ - immutableAssign({ - min_lifetime: '1 hour', - strategy: strategy, - size: '100KB' - }, additionalParams) - ] + strategies } } } + servers = await flushAndRunMultipleServers(3, config) // Get the access tokens await setAccessTokensToServers(servers) { - const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, { name: 'video 1 server 2' }) + const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 1 server 2' }) video1Server2UUID = res.body.video.uuid + video1Server2Id = res.body.video.id - await viewVideo(servers[ 1 ].url, video1Server2UUID) + await viewVideo(servers[1].url, video1Server2UUID) } await waitJobs(servers) // Server 1 and server 2 follow each other - await doubleFollow(servers[ 0 ], servers[ 1 ]) + await doubleFollow(servers[0], servers[1]) // Server 1 and server 3 follow each other - await doubleFollow(servers[ 0 ], servers[ 2 ]) + await doubleFollow(servers[0], servers[2]) // Server 2 and server 3 follow each other - await doubleFollow(servers[ 1 ], servers[ 2 ]) + await doubleFollow(servers[1], servers[2]) await waitJobs(servers) } -async function check1WebSeed (strategy: VideoRedundancyStrategy, videoUUID?: string) { +async function check1WebSeed (videoUUID?: string) { if (!videoUUID) videoUUID = video1Server2UUID const webseeds = [ - 'http://localhost:9002/static/webseed/' + videoUUID + `http://localhost:${servers[1].port}/static/webseed/${videoUUID}` ] for (const server of servers) { - { - const res = await getVideo(server.url, videoUUID) + // With token to avoid issues with video follow constraints + const res = await getVideoWithToken(server.url, server.accessToken, videoUUID) - const video: VideoDetails = res.body - for (const f of video.files) { - checkMagnetWebseeds(f, webseeds, server) - } + const video: VideoDetails = res.body + for (const f of video.files) { + checkMagnetWebseeds(f, webseeds, server) } } } -async function checkStatsWith2Webseed (strategy: VideoRedundancyStrategy) { - const res = await getStats(servers[0].url) - const data: ServerStats = res.body - - expect(data.videosRedundancy).to.have.lengthOf(1) - const stat = data.videosRedundancy[0] - - expect(stat.strategy).to.equal(strategy) - expect(stat.totalSize).to.equal(102400) - expect(stat.totalUsed).to.be.at.least(1).and.below(102401) - expect(stat.totalVideoFiles).to.equal(4) - expect(stat.totalVideos).to.equal(1) -} - -async function checkStatsWith1Webseed (strategy: VideoRedundancyStrategy) { - const res = await getStats(servers[0].url) - const data: ServerStats = res.body - - expect(data.videosRedundancy).to.have.lengthOf(1) - - const stat = data.videosRedundancy[0] - expect(stat.strategy).to.equal(strategy) - expect(stat.totalSize).to.equal(102400) - expect(stat.totalUsed).to.equal(0) - expect(stat.totalVideoFiles).to.equal(0) - expect(stat.totalVideos).to.equal(0) -} - -async function check2Webseeds (strategy: VideoRedundancyStrategy, videoUUID?: string) { +async function check2Webseeds (videoUUID?: string) { if (!videoUUID) videoUUID = video1Server2UUID const webseeds = [ - 'http://localhost:9001/static/webseed/' + videoUUID, - 'http://localhost:9002/static/webseed/' + videoUUID + `http://localhost:${servers[0].port}/static/redundancy/${videoUUID}`, + `http://localhost:${servers[1].port}/static/webseed/${videoUUID}` ] for (const server of servers) { @@ -147,20 +137,28 @@ async function check2Webseeds (strategy: VideoRedundancyStrategy, videoUUID?: st for (const file of video.files) { checkMagnetWebseeds(file, webseeds, server) - // Only servers 1 and 2 have the video - if (server.serverNumber !== 3) { - await makeGetRequest({ - url: server.url, - statusCodeExpected: 200, - path: '/static/webseed/' + `${videoUUID}-${file.resolution.id}.mp4`, - contentType: null - }) - } + await makeGetRequest({ + url: servers[0].url, + statusCodeExpected: HttpStatusCode.OK_200, + path: '/static/redundancy/' + `${videoUUID}-${file.resolution.id}.mp4`, + contentType: null + }) + await makeGetRequest({ + url: servers[1].url, + statusCodeExpected: HttpStatusCode.OK_200, + path: `/static/webseed/${videoUUID}-${file.resolution.id}.mp4`, + contentType: null + }) } } - for (const directory of [ 'test1', 'test2' ]) { - const files = await readdir(join(root(), directory, 'videos')) + const directories = [ + 'test' + servers[0].internalServerNumber + '/redundancy', + 'test' + servers[1].internalServerNumber + '/videos' + ] + + for (const directory of directories) { + const files = await readdir(join(root(), directory)) expect(files).to.have.length.at.least(4) for (const resolution of [ 240, 360, 480, 720 ]) { @@ -169,13 +167,110 @@ async function check2Webseeds (strategy: VideoRedundancyStrategy, videoUUID?: st } } +async function check0PlaylistRedundancies (videoUUID?: string) { + if (!videoUUID) videoUUID = video1Server2UUID + + for (const server of servers) { + // With token to avoid issues with video follow constraints + const res = await getVideoWithToken(server.url, server.accessToken, videoUUID) + const video: VideoDetails = res.body + + expect(video.streamingPlaylists).to.be.an('array') + expect(video.streamingPlaylists).to.have.lengthOf(1) + expect(video.streamingPlaylists[0].redundancies).to.have.lengthOf(0) + } +} + +async function check1PlaylistRedundancies (videoUUID?: string) { + if (!videoUUID) videoUUID = video1Server2UUID + + for (const server of servers) { + const res = await getVideo(server.url, videoUUID) + const video: VideoDetails = res.body + + expect(video.streamingPlaylists).to.have.lengthOf(1) + expect(video.streamingPlaylists[0].redundancies).to.have.lengthOf(1) + + const redundancy = video.streamingPlaylists[0].redundancies[0] + + expect(redundancy.baseUrl).to.equal(servers[0].url + '/static/redundancy/hls/' + videoUUID) + } + + const baseUrlPlaylist = servers[1].url + '/static/streaming-playlists/hls' + const baseUrlSegment = servers[0].url + '/static/redundancy/hls' + + const res = await getVideo(servers[0].url, videoUUID) + const hlsPlaylist = (res.body as VideoDetails).streamingPlaylists[0] + + for (const resolution of [ 240, 360, 480, 720 ]) { + await checkSegmentHash({ server: servers[1], baseUrlPlaylist, baseUrlSegment, videoUUID, resolution, hlsPlaylist }) + } + + const directories = [ + 'test' + servers[0].internalServerNumber + '/redundancy/hls', + 'test' + servers[1].internalServerNumber + '/streaming-playlists/hls' + ] + + for (const directory of directories) { + const files = await readdir(join(root(), directory, videoUUID)) + expect(files).to.have.length.at.least(4) + + for (const resolution of [ 240, 360, 480, 720 ]) { + const filename = `${videoUUID}-${resolution}-fragmented.mp4` + + expect(files.find(f => f === filename)).to.not.be.undefined + } + } +} + +async function checkStatsGlobal (strategy: VideoRedundancyStrategyWithManual) { + let totalSize: number = null + let statsLength = 1 + + if (strategy !== 'manual') { + totalSize = 409600 + statsLength = 2 + } + + const data = await servers[0].statsCommand.get() + expect(data.videosRedundancy).to.have.lengthOf(statsLength) + + const stat = data.videosRedundancy[0] + expect(stat.strategy).to.equal(strategy) + expect(stat.totalSize).to.equal(totalSize) + + return stat +} + +async function checkStatsWith1Redundancy (strategy: VideoRedundancyStrategyWithManual, onlyHls = false) { + const stat = await checkStatsGlobal(strategy) + + expect(stat.totalUsed).to.be.at.least(1).and.below(409601) + expect(stat.totalVideoFiles).to.equal(onlyHls ? 4 : 8) + expect(stat.totalVideos).to.equal(1) +} + +async function checkStatsWithoutRedundancy (strategy: VideoRedundancyStrategyWithManual) { + const stat = await checkStatsGlobal(strategy) + + expect(stat.totalUsed).to.equal(0) + expect(stat.totalVideoFiles).to.equal(0) + expect(stat.totalVideos).to.equal(0) +} + +async function findServerFollows () { + const body = await servers[0].followsCommand.getFollowings({ start: 0, count: 5, sort: '-createdAt' }) + const follows = body.data + const server2 = follows.find(f => f.following.host === `localhost:${servers[1].port}`) + const server3 = follows.find(f => f.following.host === `localhost:${servers[2].port}`) + + return { server2, server3 } +} + async function enableRedundancyOnServer1 () { - await updateRedundancy(servers[ 0 ].url, servers[ 0 ].accessToken, servers[ 1 ].host, true) + await servers[0].redundancyCommand.updateRedundancy({ host: servers[1].host, redundancyAllowed: true }) - const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 5, '-createdAt') - const follows: ActorFollow[] = res.body.data - const server2 = follows.find(f => f.following.host === 'localhost:9002') - const server3 = follows.find(f => f.following.host === 'localhost:9003') + const { server2, server3 } = await findServerFollows() expect(server3).to.not.be.undefined expect(server3.following.hostRedundancyAllowed).to.be.false @@ -185,12 +280,9 @@ async function enableRedundancyOnServer1 () { } async function disableRedundancyOnServer1 () { - await updateRedundancy(servers[ 0 ].url, servers[ 0 ].accessToken, servers[ 1 ].host, false) + await servers[0].redundancyCommand.updateRedundancy({ host: servers[1].host, redundancyAllowed: false }) - const res = await getFollowingListPaginationAndSort(servers[ 0 ].url, 0, 5, '-createdAt') - const follows: ActorFollow[] = res.body.data - const server2 = follows.find(f => f.following.host === 'localhost:9002') - const server3 = follows.find(f => f.following.host === 'localhost:9003') + const { server2, server3 } = await findServerFollows() expect(server3).to.not.be.undefined expect(server3.following.hostRedundancyAllowed).to.be.false @@ -199,10 +291,6 @@ async function disableRedundancyOnServer1 () { expect(server2.following.hostRedundancyAllowed).to.be.false } -async function cleanServers () { - killallServers(servers) -} - describe('Test videos redundancy', function () { describe('With most-views strategy', function () { @@ -211,44 +299,47 @@ describe('Test videos redundancy', function () { before(function () { this.timeout(120000) - return runServers(strategy) + return flushAndRunServers(strategy) }) it('Should have 1 webseed on the first video', async function () { - await check1WebSeed(strategy) - await checkStatsWith1Webseed(strategy) + await check1WebSeed() + await check0PlaylistRedundancies() + await checkStatsWithoutRedundancy(strategy) }) it('Should enable redundancy on server 1', function () { return enableRedundancyOnServer1() }) - it('Should have 2 webseed on the first video', async function () { - this.timeout(40000) + it('Should have 2 webseeds on the first video', async function () { + this.timeout(80000) await waitJobs(servers) - await waitUntilLog(servers[0], 'Duplicated ', 4) + await servers[0].serversCommand.waitUntilLog('Duplicated ', 5) await waitJobs(servers) - await check2Webseeds(strategy) - await checkStatsWith2Webseed(strategy) + await check2Webseeds() + await check1PlaylistRedundancies() + await checkStatsWith1Redundancy(strategy) }) it('Should undo redundancy on server 1 and remove duplicated videos', async function () { - this.timeout(40000) + this.timeout(80000) await disableRedundancyOnServer1() await waitJobs(servers) await wait(5000) - await check1WebSeed(strategy) + await check1WebSeed() + await check0PlaylistRedundancies() - await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos' ]) + await checkVideoFilesWereRemoved(video1Server2UUID, servers[0], [ 'videos', join('playlists', 'hls') ]) }) - after(function () { - return cleanServers() + after(async function () { + return cleanupTests(servers) }) }) @@ -258,44 +349,47 @@ describe('Test videos redundancy', function () { before(function () { this.timeout(120000) - return runServers(strategy) + return flushAndRunServers(strategy) }) it('Should have 1 webseed on the first video', async function () { - await check1WebSeed(strategy) - await checkStatsWith1Webseed(strategy) + await check1WebSeed() + await check0PlaylistRedundancies() + await checkStatsWithoutRedundancy(strategy) }) it('Should enable redundancy on server 1', function () { return enableRedundancyOnServer1() }) - it('Should have 2 webseed on the first video', async function () { - this.timeout(40000) + it('Should have 2 webseeds on the first video', async function () { + this.timeout(80000) await waitJobs(servers) - await waitUntilLog(servers[0], 'Duplicated ', 4) + await servers[0].serversCommand.waitUntilLog('Duplicated ', 5) await waitJobs(servers) - await check2Webseeds(strategy) - await checkStatsWith2Webseed(strategy) + await check2Webseeds() + await check1PlaylistRedundancies() + await checkStatsWith1Redundancy(strategy) }) it('Should unfollow on server 1 and remove duplicated videos', async function () { - this.timeout(40000) + this.timeout(80000) - await unfollow(servers[0].url, servers[0].accessToken, servers[1]) + await servers[0].followsCommand.unfollow({ target: servers[1] }) await waitJobs(servers) await wait(5000) - await check1WebSeed(strategy) + await check1WebSeed() + await check0PlaylistRedundancies() - await checkVideoFilesWereRemoved(video1Server2UUID, servers[0].serverNumber, [ 'videos' ]) + await checkVideoFilesWereRemoved(video1Server2UUID, servers[0], [ 'videos' ]) }) - after(function () { - return cleanServers() + after(async function () { + await cleanupTests(servers) }) }) @@ -305,12 +399,13 @@ describe('Test videos redundancy', function () { before(function () { this.timeout(120000) - return runServers(strategy, { min_views: 3 }) + return flushAndRunServers(strategy, { min_views: 3 }) }) it('Should have 1 webseed on the first video', async function () { - await check1WebSeed(strategy) - await checkStatsWith1Webseed(strategy) + await check1WebSeed() + await check0PlaylistRedundancies() + await checkStatsWithoutRedundancy(strategy) }) it('Should enable redundancy on server 1', function () { @@ -318,35 +413,37 @@ describe('Test videos redundancy', function () { }) it('Should still have 1 webseed on the first video', async function () { - this.timeout(40000) + this.timeout(80000) await waitJobs(servers) await wait(15000) await waitJobs(servers) - await check1WebSeed(strategy) - await checkStatsWith1Webseed(strategy) + await check1WebSeed() + await check0PlaylistRedundancies() + await checkStatsWithoutRedundancy(strategy) }) it('Should view 2 times the first video to have > min_views config', async function () { - this.timeout(40000) + this.timeout(80000) - await viewVideo(servers[ 0 ].url, video1Server2UUID) - await viewVideo(servers[ 2 ].url, video1Server2UUID) + await viewVideo(servers[0].url, video1Server2UUID) + await viewVideo(servers[2].url, video1Server2UUID) await wait(10000) await waitJobs(servers) }) - it('Should have 2 webseed on the first video', async function () { - this.timeout(40000) + it('Should have 2 webseeds on the first video', async function () { + this.timeout(80000) await waitJobs(servers) - await waitUntilLog(servers[0], 'Duplicated ', 4) + await servers[0].serversCommand.waitUntilLog('Duplicated ', 5) await waitJobs(servers) - await check2Webseeds(strategy) - await checkStatsWith2Webseed(strategy) + await check2Webseeds() + await check1PlaylistRedundancies() + await checkStatsWith1Redundancy(strategy) }) it('Should remove the video and the redundancy files', async function () { @@ -357,12 +454,132 @@ describe('Test videos redundancy', function () { await waitJobs(servers) for (const server of servers) { - await checkVideoFilesWereRemoved(video1Server2UUID, server.serverNumber) + await checkVideoFilesWereRemoved(video1Server2UUID, server) } }) - after(function () { - return cleanServers() + after(async function () { + await cleanupTests(servers) + }) + }) + + describe('With only HLS files', function () { + const strategy = 'recently-added' + + before(async function () { + this.timeout(120000) + + await flushAndRunServers(strategy, { min_views: 3 }, false) + }) + + it('Should have 0 playlist redundancy on the first video', async function () { + await check1WebSeed() + await check0PlaylistRedundancies() + }) + + it('Should enable redundancy on server 1', function () { + return enableRedundancyOnServer1() + }) + + it('Should still have 0 redundancy on the first video', async function () { + this.timeout(80000) + + await waitJobs(servers) + await wait(15000) + await waitJobs(servers) + + await check0PlaylistRedundancies() + await checkStatsWithoutRedundancy(strategy) + }) + + it('Should have 1 redundancy on the first video', async function () { + this.timeout(160000) + + await viewVideo(servers[0].url, video1Server2UUID) + await viewVideo(servers[2].url, video1Server2UUID) + + await wait(10000) + await waitJobs(servers) + + await waitJobs(servers) + await servers[0].serversCommand.waitUntilLog('Duplicated ', 1) + await waitJobs(servers) + + await check1PlaylistRedundancies() + await checkStatsWith1Redundancy(strategy, true) + }) + + it('Should remove the video and the redundancy files', async function () { + this.timeout(20000) + + await removeVideo(servers[1].url, servers[1].accessToken, video1Server2UUID) + + await waitJobs(servers) + + for (const server of servers) { + await checkVideoFilesWereRemoved(video1Server2UUID, server) + } + }) + + after(async function () { + await cleanupTests(servers) + }) + }) + + describe('With manual strategy', function () { + before(function () { + this.timeout(120000) + + return flushAndRunServers(null) + }) + + it('Should have 1 webseed on the first video', async function () { + await check1WebSeed() + await check0PlaylistRedundancies() + await checkStatsWithoutRedundancy('manual') + }) + + it('Should create a redundancy on first video', async function () { + await servers[0].redundancyCommand.addVideo({ videoId: video1Server2Id }) + }) + + it('Should have 2 webseeds on the first video', async function () { + this.timeout(80000) + + await waitJobs(servers) + await servers[0].serversCommand.waitUntilLog('Duplicated ', 5) + await waitJobs(servers) + + await check2Webseeds() + await check1PlaylistRedundancies() + await checkStatsWith1Redundancy('manual') + }) + + it('Should manually remove redundancies on server 1 and remove duplicated videos', async function () { + this.timeout(80000) + + const body = await servers[0].redundancyCommand.listVideos({ target: 'remote-videos' }) + + const videos = body.data + expect(videos).to.have.lengthOf(1) + + const video = videos[0] + + for (const r of video.redundancies.files.concat(video.redundancies.streamingPlaylists)) { + await servers[0].redundancyCommand.removeVideo({ redundancyId: r.id }) + } + + await waitJobs(servers) + await wait(5000) + + await check1WebSeed() + await check0PlaylistRedundancies() + + await checkVideoFilesWereRemoved(video1Server2UUID, servers[0], [ 'videos' ]) + }) + + after(async function () { + await cleanupTests(servers) }) }) @@ -394,38 +611,38 @@ describe('Test videos redundancy', function () { before(async function () { this.timeout(120000) - await runServers(strategy, { min_lifetime: '7 seconds', min_views: 0 }) + await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 }) await enableRedundancyOnServer1() }) it('Should still have 2 webseeds after 10 seconds', async function () { - this.timeout(40000) + this.timeout(80000) await wait(10000) try { - await checkContains(servers, 'http%3A%2F%2Flocalhost%3A9001') + await checkContains(servers, 'http%3A%2F%2Flocalhost%3A' + servers[0].port) } catch { // Maybe a server deleted a redundancy in the scheduler await wait(2000) - await checkContains(servers, 'http%3A%2F%2Flocalhost%3A9001') + await checkContains(servers, 'http%3A%2F%2Flocalhost%3A' + servers[0].port) } }) it('Should stop server 1 and expire video redundancy', async function () { - this.timeout(40000) + this.timeout(80000) - killallServers([ servers[0] ]) + await killallServers([ servers[0] ]) - await wait(10000) + await wait(15000) - await checkNotContains([ servers[1], servers[2] ], 'http%3A%2F%2Flocalhost%3A9001') + await checkNotContains([ servers[1], servers[2] ], 'http%3A%2F%2Flocalhost%3A' + servers[0].port) }) - after(function () { - return killallServers([ servers[1], servers[2] ]) + after(async function () { + await cleanupTests(servers) }) }) @@ -436,48 +653,73 @@ describe('Test videos redundancy', function () { before(async function () { this.timeout(120000) - await runServers(strategy, { min_lifetime: '7 seconds', min_views: 0 }) + await flushAndRunServers(strategy, { min_lifetime: '7 seconds', min_views: 0 }) await enableRedundancyOnServer1() await waitJobs(servers) - await waitUntilLog(servers[0], 'Duplicated ', 4) + await servers[0].serversCommand.waitUntilLog('Duplicated ', 5) await waitJobs(servers) - await check2Webseeds(strategy) - await checkStatsWith2Webseed(strategy) + await check2Webseeds(video1Server2UUID) + await check1PlaylistRedundancies(video1Server2UUID) + await checkStatsWith1Redundancy(strategy) - const res = await uploadVideo(servers[ 1 ].url, servers[ 1 ].accessToken, { name: 'video 2 server 2' }) + const res = await uploadVideo(servers[1].url, servers[1].accessToken, { name: 'video 2 server 2', privacy: VideoPrivacy.PRIVATE }) video2Server2UUID = res.body.video.uuid + + // Wait transcoding before federation + await waitJobs(servers) + + await updateVideo(servers[1].url, servers[1].accessToken, video2Server2UUID, { privacy: VideoPrivacy.PUBLIC }) }) - it('Should cache video 2 webseed on the first video', async function () { - this.timeout(50000) + it('Should cache video 2 webseeds on the first video', async function () { + this.timeout(120000) await waitJobs(servers) - await wait(7000) + let checked = false - try { - await check1WebSeed(strategy, video1Server2UUID) - await check2Webseeds(strategy, video2Server2UUID) - } catch { - await wait(3000) + while (checked === false) { + await wait(1000) try { - await check1WebSeed(strategy, video1Server2UUID) - await check2Webseeds(strategy, video2Server2UUID) - } catch { - await wait(5000) + await check1WebSeed(video1Server2UUID) + await check0PlaylistRedundancies(video1Server2UUID) - await check1WebSeed(strategy, video1Server2UUID) - await check2Webseeds(strategy, video2Server2UUID) + await check2Webseeds(video2Server2UUID) + await check1PlaylistRedundancies(video2Server2UUID) + + checked = true + } catch { + checked = false } } }) - after(function () { - return cleanServers() + it('Should disable strategy and remove redundancies', async function () { + this.timeout(80000) + + await waitJobs(servers) + + await killallServers([ servers[0] ]) + await reRunServer(servers[0], { + redundancy: { + videos: { + check_interval: '1 second', + strategies: [] + } + } + }) + + await waitJobs(servers) + + await checkVideoFilesWereRemoved(video1Server2UUID, servers[0], [ join('redundancy', 'hls') ]) + }) + + after(async function () { + await cleanupTests(servers) }) }) })