]>
Commit | Line | Data |
---|---|---|
09664156 | 1 | import * as program from 'commander' |
09664156 C |
2 | |
3 | // /!\ Before imports /!\ | |
4 | process.env.NODE_ENV = 'test' | |
5 | ||
6d33593a | 6 | import { Video, VideoRateType, VideoFile } from '../../../shared' |
09664156 C |
7 | import { |
8 | ServerInfo as DefaultServerInfo, | |
9 | flushAndRunMultipleServers, | |
10 | setAccessTokensToServers, | |
11 | makeFriends, | |
12 | wait, | |
13 | killallServers, | |
14 | flushTests, | |
15 | uploadVideo, | |
16 | getVideosList, | |
17 | updateVideo, | |
18 | removeVideo, | |
19 | getVideo, | |
20 | getAllVideosListBy, | |
21 | getRequestsStats | |
22 | } from '../utils' | |
23 | ||
24 | interface ServerInfo extends DefaultServerInfo { | |
25 | requestsNumber: number | |
26 | } | |
27 | ||
28 | program | |
29 | .option('-c, --create [weight]', 'Weight for creating videos') | |
30 | .option('-r, --remove [weight]', 'Weight for removing videos') | |
31 | .option('-u, --update [weight]', 'Weight for updating videos') | |
32 | .option('-v, --view [weight]', 'Weight for viewing videos') | |
33 | .option('-l, --like [weight]', 'Weight for liking videos') | |
34 | .option('-s, --dislike [weight]', 'Weight for disliking videos') | |
35 | .option('-p, --pods [n]', 'Number of pods to run (3 or 6)', /^3|6$/, 3) | |
36 | .option('-i, --interval-action [interval]', 'Interval in ms for an action') | |
37 | .option('-I, --interval-integrity [interval]', 'Interval in ms for an integrity check') | |
38 | .option('-f, --flush', 'Flush datas on exit') | |
39 | .option('-d, --difference', 'Display difference if integrity is not okay') | |
40 | .parse(process.argv) | |
41 | ||
42 | const createWeight = program['create'] !== undefined ? parseInt(program['create'], 10) : 5 | |
43 | const removeWeight = program['remove'] !== undefined ? parseInt(program['remove'], 10) : 4 | |
44 | const updateWeight = program['update'] !== undefined ? parseInt(program['update'], 10) : 4 | |
45 | const viewWeight = program['view'] !== undefined ? parseInt(program['view'], 10) : 4 | |
46 | const likeWeight = program['like'] !== undefined ? parseInt(program['like'], 10) : 4 | |
47 | const dislikeWeight = program['dislike'] !== undefined ? parseInt(program['dislike'], 10) : 4 | |
48 | const flushAtExit = program['flush'] || false | |
49 | const actionInterval = program['intervalAction'] !== undefined ? parseInt(program['intervalAction'], 10) : 500 | |
50 | const integrityInterval = program['intervalIntegrity'] !== undefined ? parseInt(program['intervalIntegrity'], 10) : 60000 | |
51 | const displayDiffOnFail = program['difference'] || false | |
52 | ||
53 | const numberOfPods = 6 | |
54 | ||
55 | console.log( | |
56 | 'Create weight: %d, update weight: %d, remove weight: %d, view weight: %d, like weight: %d, dislike weight: %d.', | |
57 | createWeight, updateWeight, removeWeight, viewWeight, likeWeight, dislikeWeight | |
58 | ) | |
59 | ||
60 | if (flushAtExit) { | |
61 | console.log('Program will flush data on exit.') | |
62 | } else { | |
63 | console.log('Program will not flush data on exit.') | |
64 | } | |
65 | if (displayDiffOnFail) { | |
66 | console.log('Program will display diff on failure.') | |
67 | } else { | |
68 | console.log('Program will not display diff on failure') | |
69 | } | |
70 | console.log('Interval in ms for each action: %d.', actionInterval) | |
71 | console.log('Interval in ms for each integrity check: %d.', integrityInterval) | |
72 | ||
73 | console.log('Run servers...') | |
74 | ||
75 | start() | |
76 | ||
77 | // ---------------------------------------------------------------------------- | |
78 | ||
79 | async function start () { | |
80 | const servers = await runServers(numberOfPods) | |
81 | ||
53abc4c2 C |
82 | process.on('exit', async () => { |
83 | await exitServers(servers, flushAtExit) | |
84 | ||
85 | return | |
86 | }) | |
09664156 C |
87 | process.on('SIGINT', goodbye) |
88 | process.on('SIGTERM', goodbye) | |
89 | ||
53abc4c2 | 90 | console.log('Servers ran') |
09664156 C |
91 | initializeRequestsPerServer(servers) |
92 | ||
93 | let checking = false | |
94 | ||
95 | setInterval(async () => { | |
96 | if (checking === true) return | |
97 | ||
98 | const rand = getRandomInt(0, createWeight + updateWeight + removeWeight + viewWeight + likeWeight + dislikeWeight) | |
99 | ||
100 | const numServer = getRandomNumServer(servers) | |
101 | servers[numServer].requestsNumber++ | |
102 | ||
103 | if (rand < createWeight) { | |
104 | await upload(servers, numServer) | |
105 | } else if (rand < createWeight + updateWeight) { | |
106 | await update(servers, numServer) | |
107 | } else if (rand < createWeight + updateWeight + removeWeight) { | |
108 | await remove(servers, numServer) | |
109 | } else if (rand < createWeight + updateWeight + removeWeight + viewWeight) { | |
110 | await view(servers, numServer) | |
111 | } else if (rand < createWeight + updateWeight + removeWeight + viewWeight + likeWeight) { | |
112 | await like(servers, numServer) | |
113 | } else { | |
114 | await dislike(servers, numServer) | |
115 | } | |
116 | }, actionInterval) | |
117 | ||
118 | // The function will check the consistency between servers (should have the same videos with same attributes...) | |
119 | setInterval(function () { | |
120 | if (checking === true) return | |
121 | ||
122 | console.log('Checking integrity...') | |
123 | checking = true | |
124 | ||
125 | const waitingInterval = setInterval(async () => { | |
6d33593a C |
126 | const pendingRequests = await isTherePendingRequests(servers) |
127 | if (pendingRequests === true) { | |
128 | console.log('A server has pending requests, waiting...') | |
09664156 C |
129 | return |
130 | } | |
131 | ||
6d33593a C |
132 | // Even if there are no pending request, wait some potential processes |
133 | await wait(2000) | |
09664156 C |
134 | await checkIntegrity(servers) |
135 | ||
136 | initializeRequestsPerServer(servers) | |
137 | checking = false | |
138 | clearInterval(waitingInterval) | |
7a7724e6 | 139 | }, 10000) |
09664156 C |
140 | }, integrityInterval) |
141 | } | |
142 | ||
143 | function initializeRequestsPerServer (servers: ServerInfo[]) { | |
144 | servers.forEach(server => server.requestsNumber = 0) | |
145 | } | |
146 | ||
147 | function getRandomInt (min, max) { | |
148 | return Math.floor(Math.random() * (max - min)) + min | |
149 | } | |
150 | ||
151 | function getRandomNumServer (servers) { | |
152 | return getRandomInt(0, servers.length) | |
153 | } | |
154 | ||
155 | async function runServers (numberOfPods: number) { | |
53abc4c2 C |
156 | const servers: ServerInfo[] = (await flushAndRunMultipleServers(numberOfPods)) |
157 | .map(s => Object.assign({ requestsNumber: 0 }, s)) | |
09664156 C |
158 | |
159 | // Get the access tokens | |
160 | await setAccessTokensToServers(servers) | |
161 | ||
162 | await makeFriends(servers[1].url, servers[1].accessToken) | |
163 | await makeFriends(servers[0].url, servers[0].accessToken) | |
164 | await wait(1000) | |
165 | ||
166 | await makeFriends(servers[3].url, servers[3].accessToken) | |
167 | await makeFriends(servers[5].url, servers[5].accessToken) | |
168 | await makeFriends(servers[4].url, servers[4].accessToken) | |
169 | ||
170 | await wait(1000) | |
171 | ||
172 | return servers | |
173 | } | |
174 | ||
175 | async function exitServers (servers: ServerInfo[], flushAtExit: boolean) { | |
176 | killallServers(servers) | |
177 | ||
178 | if (flushAtExit) await flushTests() | |
179 | } | |
180 | ||
181 | function upload (servers: ServerInfo[], numServer: number) { | |
182 | console.log('Uploading video to server ' + numServer) | |
183 | ||
184 | const videoAttributes = { | |
185 | name: Date.now() + ' name', | |
186 | category: 4, | |
187 | nsfw: false, | |
188 | licence: 2, | |
189 | language: 1, | |
190 | description: Date.now() + ' description', | |
191 | tags: [ Date.now().toString().substring(0, 5) + 't1', Date.now().toString().substring(0, 5) + 't2' ], | |
192 | fixture: 'video_short1.webm' | |
193 | } | |
194 | return uploadVideo(servers[numServer].url, servers[numServer].accessToken, videoAttributes) | |
195 | } | |
196 | ||
197 | async function update (servers: ServerInfo[], numServer: number) { | |
198 | const res = await getVideosList(servers[numServer].url) | |
199 | ||
200 | const videos = res.body.data.filter(video => video.isLocal === true) | |
201 | if (videos.length === 0) return undefined | |
202 | ||
203 | const toUpdate = videos[getRandomInt(0, videos.length)].id | |
204 | const attributes = { | |
205 | name: Date.now() + ' name', | |
206 | description: Date.now() + ' description', | |
207 | tags: [ Date.now().toString().substring(0, 5) + 't1', Date.now().toString().substring(0, 5) + 't2' ] | |
208 | } | |
209 | ||
210 | console.log('Updating video of server ' + numServer) | |
211 | ||
212 | return updateVideo(servers[numServer].url, servers[numServer].accessToken, toUpdate, attributes) | |
213 | } | |
214 | ||
215 | async function remove (servers: ServerInfo[], numServer: number) { | |
216 | const res = await getVideosList(servers[numServer].url) | |
6d33593a | 217 | const videos = res.body.data.filter(video => video.isLocal === true) |
09664156 C |
218 | if (videos.length === 0) return undefined |
219 | ||
220 | const toRemove = videos[getRandomInt(0, videos.length)].id | |
221 | ||
222 | console.log('Removing video from server ' + numServer) | |
223 | return removeVideo(servers[numServer].url, servers[numServer].accessToken, toRemove) | |
224 | } | |
225 | ||
226 | async function view (servers: ServerInfo[], numServer: number) { | |
227 | const res = await getVideosList(servers[numServer].url) | |
228 | ||
229 | const videos = res.body.data | |
230 | if (videos.length === 0) return undefined | |
231 | ||
232 | const toView = videos[getRandomInt(0, videos.length)].id | |
233 | ||
234 | console.log('Viewing video from server ' + numServer) | |
235 | return getVideo(servers[numServer].url, toView) | |
236 | } | |
237 | ||
238 | function like (servers: ServerInfo[], numServer: number) { | |
239 | return rate(servers, numServer, 'like') | |
240 | } | |
241 | ||
242 | function dislike (servers: ServerInfo[], numServer: number) { | |
243 | return rate(servers, numServer, 'dislike') | |
244 | } | |
245 | ||
246 | async function rate (servers: ServerInfo[], numServer: number, rating: VideoRateType) { | |
247 | const res = await getVideosList(servers[numServer].url) | |
248 | ||
249 | const videos = res.body.data | |
250 | if (videos.length === 0) return undefined | |
251 | ||
252 | const toRate = videos[getRandomInt(0, videos.length)].id | |
253 | ||
254 | console.log('Rating (%s) video from server %d', rating, numServer) | |
255 | return getVideo(servers[numServer].url, toRate) | |
256 | } | |
257 | ||
258 | async function checkIntegrity (servers: ServerInfo[]) { | |
259 | const videos: Video[][] = [] | |
260 | const tasks: Promise<any>[] = [] | |
261 | ||
262 | // Fetch all videos and remove some fields that can differ between pods | |
263 | for (const server of servers) { | |
6d33593a | 264 | const p = getAllVideosListBy(server.url).then(res => videos.push(res.body.data)) |
09664156 C |
265 | tasks.push(p) |
266 | } | |
267 | ||
268 | await Promise.all(tasks) | |
269 | ||
270 | let i = 0 | |
271 | for (const video of videos) { | |
6d33593a C |
272 | const differences = areDifferences(video, videos[0]) |
273 | if (differences !== undefined) { | |
09664156 C |
274 | console.error('Integrity not ok with server %d!', i + 1) |
275 | ||
276 | if (displayDiffOnFail) { | |
6d33593a | 277 | console.log(differences) |
09664156 C |
278 | } |
279 | ||
280 | process.exit(-1) | |
281 | } | |
282 | ||
283 | i++ | |
284 | } | |
285 | ||
286 | console.log('Integrity ok.') | |
287 | } | |
288 | ||
6d33593a C |
289 | function areDifferences (videos1: Video[], videos2: Video[]) { |
290 | // Remove some keys we don't want to compare | |
291 | videos1.concat(videos2).forEach(video => { | |
292 | delete video.id | |
293 | delete video.isLocal | |
294 | delete video.thumbnailPath | |
295 | delete video.updatedAt | |
296 | delete video.views | |
297 | }) | |
298 | ||
299 | if (videos1.length !== videos2.length) { | |
300 | return `Videos length are different (${videos1.length}/${videos2.length}).` | |
301 | } | |
302 | ||
303 | for (const video1 of videos1) { | |
304 | const video2 = videos2.find(video => video.uuid === video1.uuid) | |
305 | ||
306 | if (!video2) return 'Video ' + video1.uuid + ' is missing.' | |
307 | ||
308 | for (const videoKey of Object.keys(video1)) { | |
309 | const attribute1 = video1[videoKey] | |
310 | const attribute2 = video2[videoKey] | |
311 | ||
312 | if (videoKey === 'tags') { | |
313 | if (attribute1.length !== attribute2.length) { | |
314 | return 'Tags are different.' | |
315 | } | |
316 | ||
317 | attribute1.forEach(tag1 => { | |
318 | if (attribute2.indexOf(tag1) === -1) { | |
319 | return 'Tag ' + tag1 + ' is missing.' | |
320 | } | |
321 | }) | |
322 | } else if (videoKey === 'files') { | |
323 | if (attribute1.length !== attribute2.length) { | |
324 | return 'Video files are different.' | |
325 | } | |
326 | ||
327 | attribute1.forEach((videoFile1: VideoFile) => { | |
328 | const videoFile2: VideoFile = attribute2.find(videoFile => videoFile.magnetUri === videoFile1.magnetUri) | |
329 | if (!videoFile2) { | |
330 | return `Video ${video1.uuid} has missing video file ${videoFile1.magnetUri}.` | |
331 | } | |
332 | ||
333 | if (videoFile1.size !== videoFile2.size || videoFile1.resolutionLabel !== videoFile2.resolutionLabel) { | |
334 | return `Video ${video1.uuid} has different video file ${videoFile1.magnetUri}.` | |
335 | } | |
336 | }) | |
337 | } else { | |
338 | if (attribute1 !== attribute2) { | |
339 | return `Video ${video1.uuid} has different value for attribute ${videoKey}.` | |
340 | } | |
341 | } | |
342 | } | |
343 | } | |
344 | ||
345 | return undefined | |
346 | } | |
347 | ||
09664156 C |
348 | function goodbye () { |
349 | return process.exit(-1) | |
350 | } | |
351 | ||
6d33593a | 352 | async function isTherePendingRequests (servers: ServerInfo[]) { |
09664156 | 353 | const tasks: Promise<any>[] = [] |
6d33593a | 354 | let pendingRequests = false |
09664156 | 355 | |
6d33593a | 356 | // Check if each server has pending request |
09664156 C |
357 | for (const server of servers) { |
358 | const p = getRequestsStats(server).then(res => { | |
359 | const stats = res.body | |
360 | ||
361 | if ( | |
362 | stats.requestScheduler.totalRequests !== 0 || | |
363 | stats.requestVideoEventScheduler.totalRequests !== 0 || | |
364 | stats.requestVideoQaduScheduler.totalRequests !== 0 | |
365 | ) { | |
6d33593a | 366 | pendingRequests = true |
09664156 C |
367 | } |
368 | }) | |
369 | ||
370 | tasks.push(p) | |
371 | } | |
372 | ||
373 | await Promise.all(tasks) | |
374 | ||
6d33593a | 375 | return pendingRequests |
09664156 | 376 | } |