X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=shared%2Fextra-utils%2Fserver%2Fservers.ts;h=e0e49d2c4b076c070e9cd74c92b8337ac1569136;hb=dd0ebb715123dfa126a82d4e4fe3a04064ae77b8;hp=a0f0ce9c9792f11885e0a8ff5cd0814ab057bb65;hpb=a15871560f80e07386c1dabb8370cd2664ecfd1f;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/shared/extra-utils/server/servers.ts b/shared/extra-utils/server/servers.ts
index a0f0ce9c9..e0e49d2c4 100644
--- a/shared/extra-utils/server/servers.ts
+++ b/shared/extra-utils/server/servers.ts
@@ -1,29 +1,66 @@
 /* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/no-floating-promises */
 
+import { expect } from 'chai'
 import { ChildProcess, exec, fork } from 'child_process'
+import { copy, ensureDir, pathExists, readdir, readFile, remove } from 'fs-extra'
 import { join } from 'path'
-import { root, wait } from '../miscs/miscs'
-import { copy, pathExists, readdir, readFile, remove } from 'fs-extra'
-import { expect } from 'chai'
-import { VideoChannel } from '../../models/videos'
 import { randomInt } from '../../core-utils/miscs/miscs'
+import { VideoChannel } from '../../models/videos'
+import { BulkCommand } from '../bulk'
+import { CLICommand } from '../cli'
+import { CustomPagesCommand } from '../custom-pages'
+import { FeedCommand } from '../feeds'
+import { LogsCommand } from '../logs'
+import { SQLCommand } from '../miscs'
+import { buildServerDirectory, getFileSize, isGithubCI, root, wait } from '../miscs/miscs'
+import { AbusesCommand } from '../moderation'
+import { OverviewsCommand } from '../overviews'
+import { makeGetRequest } from '../requests/requests'
+import { SearchCommand } from '../search'
+import { SocketIOCommand } from '../socket'
+import { AccountsCommand, BlocklistCommand, NotificationsCommand, SubscriptionsCommand } from '../users'
+import {
+  BlacklistCommand,
+  CaptionsCommand,
+  ChangeOwnershipCommand,
+  ChannelsCommand,
+  HistoryCommand,
+  ImportsCommand,
+  LiveCommand,
+  PlaylistsCommand,
+  ServicesCommand,
+  StreamingPlaylistsCommand
+} from '../videos'
+import { CommentsCommand } from '../videos/comments-command'
+import { ConfigCommand } from './config-command'
+import { ContactFormCommand } from './contact-form-command'
+import { DebugCommand } from './debug-command'
+import { FollowsCommand } from './follows-command'
+import { JobsCommand } from './jobs-command'
+import { PluginsCommand } from './plugins-command'
+import { RedundancyCommand } from './redundancy-command'
+import { StatsCommand } from './stats-command'
 
 interface ServerInfo {
-  app: ChildProcess
+  app?: ChildProcess
+
   url: string
-  host: string
+  host?: string
+  hostname?: string
+  port?: number
 
-  port: number
-  parallel: boolean
+  rtmpPort?: number
+
+  parallel?: boolean
   internalServerNumber: number
-  serverNumber: number
+  serverNumber?: number
 
-  client: {
-    id: string
-    secret: string
+  client?: {
+    id?: string
+    secret?: string
   }
 
-  user: {
+  user?: {
     username: string
     password: string
     email?: string
@@ -32,15 +69,21 @@ interface ServerInfo {
   customConfigFile?: string
 
   accessToken?: string
+  refreshToken?: string
   videoChannel?: VideoChannel
 
   video?: {
     id: number
     uuid: string
-    name: string
-    account: {
+    shortUUID: string
+    name?: string
+    url?: string
+
+    account?: {
       name: string
     }
+
+    embedPath?: string
   }
 
   remoteVideo?: {
@@ -49,6 +92,40 @@ interface ServerInfo {
   }
 
   videos?: { id: number, uuid: string }[]
+
+  bulkCommand?: BulkCommand
+  cliCommand?: CLICommand
+  customPageCommand?: CustomPagesCommand
+  feedCommand?: FeedCommand
+  logsCommand?: LogsCommand
+  abusesCommand?: AbusesCommand
+  overviewsCommand?: OverviewsCommand
+  searchCommand?: SearchCommand
+  contactFormCommand?: ContactFormCommand
+  debugCommand?: DebugCommand
+  followsCommand?: FollowsCommand
+  jobsCommand?: JobsCommand
+  pluginsCommand?: PluginsCommand
+  redundancyCommand?: RedundancyCommand
+  statsCommand?: StatsCommand
+  configCommand?: ConfigCommand
+  socketIOCommand?: SocketIOCommand
+  accountsCommand?: AccountsCommand
+  blocklistCommand?: BlocklistCommand
+  subscriptionsCommand?: SubscriptionsCommand
+  liveCommand?: LiveCommand
+  servicesCommand?: ServicesCommand
+  blacklistCommand?: BlacklistCommand
+  captionsCommand?: CaptionsCommand
+  changeOwnershipCommand?: ChangeOwnershipCommand
+  playlistsCommand?: PlaylistsCommand
+  historyCommand?: HistoryCommand
+  importsCommand?: ImportsCommand
+  streamingPlaylistsCommand?: StreamingPlaylistsCommand
+  channelsCommand?: ChannelsCommand
+  commentsCommand?: CommentsCommand
+  sqlCommand?: SQLCommand
+  notificationsCommand?: NotificationsCommand
 }
 
 function parallelTests () {
@@ -93,10 +170,23 @@ function randomServer () {
   return randomInt(low, high)
 }
 
-async function flushAndRunServer (serverNumber: number, configOverride?: Object, args = []) {
+function randomRTMP () {
+  const low = 1900
+  const high = 2100
+
+  return randomInt(low, high)
+}
+
+type RunServerOptions = {
+  hideLogs?: boolean
+  execArgv?: string[]
+}
+
+async function flushAndRunServer (serverNumber: number, configOverride?: Object, args = [], options: RunServerOptions = {}) {
   const parallel = parallelTests()
 
   const internalServerNumber = parallel ? randomServer() : serverNumber
+  const rtmpPort = parallel ? randomRTMP() : 1936
   const port = 9000 + internalServerNumber
 
   await flushTests(internalServerNumber)
@@ -105,10 +195,12 @@ async function flushAndRunServer (serverNumber: number, configOverride?: Object,
     app: null,
     port,
     internalServerNumber,
+    rtmpPort,
     parallel,
     serverNumber,
     url: `http://localhost:${port}`,
     host: `localhost:${port}`,
+    hostname: 'localhost',
     client: {
       id: null,
       secret: null
@@ -119,13 +211,13 @@ async function flushAndRunServer (serverNumber: number, configOverride?: Object,
     }
   }
 
-  return runServer(server, configOverride, args)
+  return runServer(server, configOverride, args, options)
 }
 
-async function runServer (server: ServerInfo, configOverrideArg?: any, args = []) {
+async function runServer (server: ServerInfo, configOverrideArg?: any, args = [], options: RunServerOptions = {}) {
   // These actions are async so we need to be sure that they have both been done
   const serverRunString = {
-    'Server listening': false
+    'HTTP server listening': false
   }
   const key = 'Database peertube_test' + server.internalServerNumber + ' is ready'
   serverRunString[key] = false
@@ -175,6 +267,11 @@ async function runServer (server: ServerInfo, configOverrideArg?: any, args = []
       },
       admin: {
         email: `admin${server.internalServerNumber}@example.com`
+      },
+      live: {
+        rtmp: {
+          port: server.rtmpPort
+        }
       }
     })
   }
@@ -189,14 +286,15 @@ async function runServer (server: ServerInfo, configOverrideArg?: any, args = []
   env['NODE_APP_INSTANCE'] = server.internalServerNumber.toString()
   env['NODE_CONFIG'] = JSON.stringify(configOverride)
 
-  const options = {
+  const forkOptions = {
     silent: true,
     env,
-    detached: true
+    detached: true,
+    execArgv: options.execArgv || []
   }
 
   return new Promise<ServerInfo>(res => {
-    server.app = fork(join(root(), 'dist', 'server.js'), args, options)
+    server.app = fork(join(root(), 'dist', 'server.js'), args, forkOptions)
     server.app.stdout.on('data', function onStdout (data) {
       let dontContinue = false
 
@@ -221,7 +319,11 @@ async function runServer (server: ServerInfo, configOverrideArg?: any, args = []
       // If no, there is maybe one thing not already initialized (client/user credentials generation...)
       if (dontContinue === true) return
 
-      server.app.stdout.removeListener('data', onStdout)
+      if (options.hideLogs === false) {
+        console.log(data.toString())
+      } else {
+        server.app.stdout.removeListener('data', onStdout)
+      }
 
       process.on('exit', () => {
         try {
@@ -229,11 +331,49 @@ async function runServer (server: ServerInfo, configOverrideArg?: any, args = []
         } catch { /* empty */ }
       })
 
+      assignCommands(server)
+
       res(server)
     })
   })
 }
 
+function assignCommands (server: ServerInfo) {
+  server.bulkCommand = new BulkCommand(server)
+  server.cliCommand = new CLICommand(server)
+  server.customPageCommand = new CustomPagesCommand(server)
+  server.feedCommand = new FeedCommand(server)
+  server.logsCommand = new LogsCommand(server)
+  server.abusesCommand = new AbusesCommand(server)
+  server.overviewsCommand = new OverviewsCommand(server)
+  server.searchCommand = new SearchCommand(server)
+  server.contactFormCommand = new ContactFormCommand(server)
+  server.debugCommand = new DebugCommand(server)
+  server.followsCommand = new FollowsCommand(server)
+  server.jobsCommand = new JobsCommand(server)
+  server.pluginsCommand = new PluginsCommand(server)
+  server.redundancyCommand = new RedundancyCommand(server)
+  server.statsCommand = new StatsCommand(server)
+  server.configCommand = new ConfigCommand(server)
+  server.socketIOCommand = new SocketIOCommand(server)
+  server.accountsCommand = new AccountsCommand(server)
+  server.blocklistCommand = new BlocklistCommand(server)
+  server.subscriptionsCommand = new SubscriptionsCommand(server)
+  server.liveCommand = new LiveCommand(server)
+  server.servicesCommand = new ServicesCommand(server)
+  server.blacklistCommand = new BlacklistCommand(server)
+  server.captionsCommand = new CaptionsCommand(server)
+  server.changeOwnershipCommand = new ChangeOwnershipCommand(server)
+  server.playlistsCommand = new PlaylistsCommand(server)
+  server.historyCommand = new HistoryCommand(server)
+  server.importsCommand = new ImportsCommand(server)
+  server.streamingPlaylistsCommand = new StreamingPlaylistsCommand(server)
+  server.channelsCommand = new ChannelsCommand(server)
+  server.commentsCommand = new CommentsCommand(server)
+  server.sqlCommand = new SQLCommand(server)
+  server.notificationsCommand = new NotificationsCommand(server)
+}
+
 async function reRunServer (server: ServerInfo, configOverride?: any) {
   const newServer = await runServer(server, configOverride)
   server.app = newServer.app
@@ -241,8 +381,12 @@ async function reRunServer (server: ServerInfo, configOverride?: any) {
   return server
 }
 
-function checkTmpIsEmpty (server: ServerInfo) {
-  return checkDirectoryIsEmpty(server, 'tmp', [ 'plugins-global.css' ])
+async function checkTmpIsEmpty (server: ServerInfo) {
+  await checkDirectoryIsEmpty(server, 'tmp', [ 'plugins-global.css', 'hls', 'resumable-uploads' ])
+
+  if (await pathExists(join('test' + server.internalServerNumber, 'tmp', 'hls'))) {
+    await checkDirectoryIsEmpty(server, 'tmp/hls')
+  }
 }
 
 async function checkDirectoryIsEmpty (server: ServerInfo, directory: string, exceptions: string[] = []) {
@@ -259,20 +403,35 @@ async function checkDirectoryIsEmpty (server: ServerInfo, directory: string, exc
   expect(filtered).to.have.lengthOf(0)
 }
 
-function killallServers (servers: ServerInfo[]) {
+async function killallServers (servers: ServerInfo[]) {
   for (const server of servers) {
     if (!server.app) continue
 
+    await server.sqlCommand.cleanup()
+
     process.kill(-server.app.pid)
+
     server.app = null
   }
 }
 
-function cleanupTests (servers: ServerInfo[]) {
-  killallServers(servers)
+async function cleanupTests (servers: ServerInfo[]) {
+  await killallServers(servers)
+
+  if (isGithubCI()) {
+    await ensureDir('artifacts')
+  }
 
   const p: Promise<any>[] = []
   for (const server of servers) {
+    if (isGithubCI()) {
+      const origin = await buildServerDirectory(server, 'logs/peertube.log')
+      const destname = `peertube-${server.internalServerNumber}.log`
+      console.log('Saving logs %s.', destname)
+
+      await copy(origin, join('artifacts', destname))
+    }
+
     if (server.parallel) {
       p.push(flushTests(server.internalServerNumber))
     }
@@ -285,31 +444,49 @@ function cleanupTests (servers: ServerInfo[]) {
   return Promise.all(p)
 }
 
-async function waitUntilLog (server: ServerInfo, str: string, count = 1) {
-  const logfile = join(root(), 'test' + server.internalServerNumber, 'logs/peertube.log')
+async function waitUntilLog (server: ServerInfo, str: string, count = 1, strictCount = true) {
+  const logfile = buildServerDirectory(server, 'logs/peertube.log')
 
   while (true) {
     const buf = await readFile(logfile)
 
     const matches = buf.toString().match(new RegExp(str, 'g'))
     if (matches && matches.length === count) return
+    if (matches && strictCount === false && matches.length >= count) return
 
     await wait(1000)
   }
 }
 
+async function getServerFileSize (server: ServerInfo, subPath: string) {
+  const path = buildServerDirectory(server, subPath)
+
+  return getFileSize(path)
+}
+
+function makePingRequest (server: ServerInfo) {
+  return makeGetRequest({
+    url: server.url,
+    path: '/api/v1/ping',
+    statusCodeExpected: 200
+  })
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   checkDirectoryIsEmpty,
   checkTmpIsEmpty,
+  getServerFileSize,
   ServerInfo,
   parallelTests,
   cleanupTests,
   flushAndRunMultipleServers,
   flushTests,
+  makePingRequest,
   flushAndRunServer,
   killallServers,
   reRunServer,
+  assignCommands,
   waitUntilLog
 }