X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server.ts;h=dd595e9512303e22a6f6e5fb4fcf1f5c0d0f5df2;hb=c2419476302b20e9fe3708d7a0a889ae18c95c1b;hp=c19ec4f194b7e01add2d3a112880af44cedf1734;hpb=e3a682a877a10833cb54ac3595e55110bda95647;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server.ts b/server.ts
index c19ec4f19..dd595e951 100644
--- a/server.ts
+++ b/server.ts
@@ -1,125 +1,221 @@
-// FIXME: https://github.com/nodejs/node/pull/16853
-require('tls').DEFAULT_ECDH_CURVE = 'auto'
-
-import { isTestInstance } from './server/helpers/core-utils'
-
-if (isTestInstance()) {
-  require('source-map-support').install()
-}
-
 // ----------- Node modules -----------
-import * as bodyParser from 'body-parser'
-import * as express from 'express'
-import * as http from 'http'
-import * as morgan from 'morgan'
-import * as path from 'path'
-import * as bitTorrentTracker from 'bittorrent-tracker'
-import * as cors from 'cors'
-import { Server as WebSocketServer } from 'ws'
-
-const TrackerServer = bitTorrentTracker.Server
+import { registerOpentelemetryTracing } from './server/lib/opentelemetry/tracing'
+registerOpentelemetryTracing()
+
+import express from 'express'
+import morgan, { token } from 'morgan'
+import cors from 'cors'
+import cookieParser from 'cookie-parser'
+import { frameguard } from 'helmet'
+import { parse } from 'useragent'
+import anonymize from 'ip-anonymize'
+import { program as cli } from 'commander'
 
 process.title = 'peertube'
 
 // Create our main app
-const app = express()
+const app = express().disable('x-powered-by')
 
 // ----------- Core checker -----------
-import { checkMissedConfig, checkFFmpeg, checkConfig } from './server/initializers/checker'
+import { checkMissedConfig, checkFFmpeg, checkNodeVersion } from './server/initializers/checker-before-init'
+
+// Do not use barrels because we don't want to load all modules here (we need to initialize database first)
+import { CONFIG } from './server/initializers/config'
+import { API_VERSION, FILES_CACHE, WEBSERVER, loadLanguages } from './server/initializers/constants'
+import { logger } from './server/helpers/logger'
 
 const missed = checkMissedConfig()
 if (missed.length !== 0) {
-  throw new Error('Your configuration files miss keys: ' + missed)
+  logger.error('Your configuration files miss keys: ' + missed)
+  process.exit(-1)
 }
 
-import { ACCEPT_HEADERS, API_VERSION, CONFIG, STATIC_PATHS } from './server/initializers/constants'
 checkFFmpeg(CONFIG)
+  .catch(err => {
+    logger.error('Error in ffmpeg check.', { err })
+    process.exit(-1)
+  })
 
-const errorMessage = checkConfig()
-if (errorMessage !== null) {
-  throw new Error(errorMessage)
+try {
+  checkNodeVersion()
+} catch (err) {
+  logger.error('Error in NodeJS check.', { err })
+  process.exit(-1)
+}
+
+import { checkConfig, checkActivityPubUrls, checkFFmpegVersion } from './server/initializers/checker-after-init'
+
+try {
+  checkConfig()
+} catch (err) {
+  logger.error('Config error.', { err })
+  process.exit(-1)
+}
+
+// Trust our proxy (IP forwarding...)
+app.set('trust proxy', CONFIG.TRUST_PROXY)
+
+app.use((_req, res, next) => {
+  res.locals.requestStart = Date.now()
+
+  return next()
+})
+
+// Security middleware
+import { baseCSP } from './server/middlewares/csp'
+
+if (CONFIG.CSP.ENABLED) {
+  app.use(baseCSP)
+}
+
+if (CONFIG.SECURITY.FRAMEGUARD.ENABLED) {
+  app.use(frameguard({
+    action: 'deny' // we only allow it for /videos/embed, see server/controllers/client.ts
+  }))
 }
 
 // ----------- Database -----------
-// Do not use barrels because we don't want to load all modules here (we need to initialize database first)
-import { logger } from './server/helpers/logger'
 
 // Initialize database and models
-import { initDatabaseModels } from './server/initializers/database'
+import { initDatabaseModels, checkDatabaseConnectionOrDie } from './server/initializers/database'
+checkDatabaseConnectionOrDie()
+
 import { migrate } from './server/initializers/migrator'
 migrate()
   .then(() => initDatabaseModels(false))
-  .then(() => onDatabaseInitDone())
+  .then(() => startApplication())
+  .catch(err => {
+    logger.error('Cannot start application.', { err })
+    process.exit(-1)
+  })
+
+// ----------- Initialize -----------
+loadLanguages()
 
 // ----------- PeerTube modules -----------
-import { installApplication } from './server/initializers'
+import { installApplication } from './server/initializers/installer'
 import { Emailer } from './server/lib/emailer'
 import { JobQueue } from './server/lib/job-queue'
-import { VideosPreviewCache } from './server/lib/cache'
-import { apiRouter, clientsRouter, staticRouter, servicesRouter, webfingerRouter, activityPubRouter } from './server/controllers'
+import { VideosPreviewCache, VideosCaptionCache } from './server/lib/files-cache'
+import {
+  activityPubRouter,
+  apiRouter,
+  miscRouter,
+  clientsRouter,
+  feedsRouter,
+  staticRouter,
+  wellKnownRouter,
+  lazyStaticRouter,
+  servicesRouter,
+  objectStorageProxyRouter,
+  pluginsRouter,
+  webfingerRouter,
+  trackerRouter,
+  createWebsocketTrackerServer,
+  botsRouter,
+  downloadRouter
+} from './server/controllers'
+import { advertiseDoNotTrack } from './server/middlewares/dnt'
+import { apiFailMiddleware } from './server/middlewares/error'
 import { Redis } from './server/lib/redis'
-import { BadActorFollowScheduler } from './server/lib/schedulers/bad-actor-follow-scheduler'
+import { ActorFollowScheduler } from './server/lib/schedulers/actor-follow-scheduler'
+import { RemoveOldViewsScheduler } from './server/lib/schedulers/remove-old-views-scheduler'
 import { RemoveOldJobsScheduler } from './server/lib/schedulers/remove-old-jobs-scheduler'
+import { UpdateVideosScheduler } from './server/lib/schedulers/update-videos-scheduler'
+import { YoutubeDlUpdateScheduler } from './server/lib/schedulers/youtube-dl-update-scheduler'
+import { VideosRedundancyScheduler } from './server/lib/schedulers/videos-redundancy-scheduler'
+import { RemoveOldHistoryScheduler } from './server/lib/schedulers/remove-old-history-scheduler'
+import { AutoFollowIndexInstances } from './server/lib/schedulers/auto-follow-index-instances'
+import { RemoveDanglingResumableUploadsScheduler } from './server/lib/schedulers/remove-dangling-resumable-uploads-scheduler'
+import { VideoViewsBufferScheduler } from './server/lib/schedulers/video-views-buffer-scheduler'
+import { GeoIPUpdateScheduler } from './server/lib/schedulers/geo-ip-update-scheduler'
+import { isHTTPSignatureDigestValid } from './server/helpers/peertube-crypto'
+import { PeerTubeSocket } from './server/lib/peertube-socket'
+import { updateStreamingPlaylistsInfohashesIfNeeded } from './server/lib/hls'
+import { PluginsCheckScheduler } from './server/lib/schedulers/plugins-check-scheduler'
+import { PeerTubeVersionCheckScheduler } from './server/lib/schedulers/peertube-version-check-scheduler'
+import { Hooks } from './server/lib/plugins/hooks'
+import { PluginManager } from './server/lib/plugins/plugin-manager'
+import { LiveManager } from './server/lib/live'
+import { HttpStatusCode } from './shared/models/http/http-error-codes'
+import { VideosTorrentCache } from '@server/lib/files-cache/videos-torrent-cache'
+import { ServerConfigManager } from '@server/lib/server-config-manager'
+import { VideoViewsManager } from '@server/lib/views/video-views-manager'
+import { isTestOrDevInstance } from './server/helpers/core-utils'
+import { OpenTelemetryMetrics } from '@server/lib/opentelemetry/metrics'
+import { ApplicationModel } from '@server/models/application/application'
+import { VideoChannelSyncLatestScheduler } from '@server/lib/schedulers/video-channel-sync-latest-scheduler'
 
 // ----------- Command line -----------
 
+cli
+  .option('--no-client', 'Start PeerTube without client interface')
+  .option('--no-plugins', 'Start PeerTube without plugins/themes enabled')
+  .option('--benchmark-startup', 'Automatically stop server when initialized')
+  .parse(process.argv)
+
 // ----------- App -----------
 
 // Enable CORS for develop
-if (isTestInstance()) {
-  app.use((req, res, next) => {
-    // These routes have already cors
-    if (
-      req.path.indexOf(STATIC_PATHS.TORRENTS) === -1 &&
-      req.path.indexOf(STATIC_PATHS.WEBSEED) === -1
-    ) {
-      return (cors({
-        origin: 'http://localhost:3000',
-        credentials: true
-      }))(req, res, next)
-    }
-
-    return next()
-  })
+if (isTestOrDevInstance()) {
+  app.use(cors({
+    origin: '*',
+    exposedHeaders: 'Retry-After',
+    credentials: true
+  }))
 }
 
 // For the logger
+token('remote-addr', (req: express.Request) => {
+  if (CONFIG.LOG.ANONYMIZE_IP === true || req.get('DNT') === '1') {
+    return anonymize(req.ip, 16, 16)
+  }
+
+  return req.ip
+})
+token('user-agent', (req: express.Request) => {
+  if (req.get('DNT') === '1') {
+    return parse(req.get('user-agent')).family
+  }
+
+  return req.get('user-agent')
+})
 app.use(morgan('combined', {
-  stream: { write: logger.info.bind(logger) }
+  stream: {
+    write: (str: string) => logger.info(str.trim(), { tags: [ 'http' ] })
+  },
+  skip: req => CONFIG.LOG.LOG_PING_REQUESTS === false && req.originalUrl === '/api/v1/ping'
 }))
+
+// Add .fail() helper to response
+app.use(apiFailMiddleware)
+
 // For body requests
-app.use(bodyParser.json({
+app.use(express.urlencoded({ extended: false }))
+app.use(express.json({
   type: [ 'application/json', 'application/*+json' ],
-  limit: '500kb'
+  limit: '500kb',
+  verify: (req: express.Request, res: express.Response, buf: Buffer) => {
+    const valid = isHTTPSignatureDigestValid(buf, req)
+
+    if (valid !== true) {
+      res.fail({
+        status: HttpStatusCode.FORBIDDEN_403,
+        message: 'Invalid digest'
+      })
+    }
+  }
 }))
-app.use(bodyParser.urlencoded({ extended: false }))
 
-// ----------- Tracker -----------
+// Cookies
+app.use(cookieParser())
 
-const trackerServer = new TrackerServer({
-  http: false,
-  udp: false,
-  ws: false,
-  dht: false
-})
+// W3C DNT Tracking Status
+app.use(advertiseDoNotTrack)
 
-trackerServer.on('error', function (err) {
-  logger.error('Error in websocket tracker.', err)
-})
+// ----------- Open Telemetry -----------
 
-trackerServer.on('warning', function (err) {
-  logger.error('Warning in websocket tracker.', err)
-})
-
-const server = http.createServer(app)
-const wss = new WebSocketServer({ server: server, path: '/tracker/socket' })
-wss.on('connection', function (ws) {
-  trackerServer.onWebSocketConnection(ws)
-})
-
-const onHttpRequest = trackerServer.onHttpRequest.bind(trackerServer)
-app.get('/tracker/announce', (req, res) => onHttpRequest(req, res, { action: 'announce' }))
-app.get('/tracker/scrape', (req, res) => onHttpRequest(req, res, { action: 'scrape' }))
+OpenTelemetryMetrics.Instance.init(app)
 
 // ----------- Views, routes and static files -----------
 
@@ -130,69 +226,156 @@ app.use(apiRoute, apiRouter)
 // Services (oembed...)
 app.use('/services', servicesRouter)
 
-app.use('/', webfingerRouter)
-app.use('/', activityPubRouter)
+// Plugins & themes
+app.use('/', pluginsRouter)
 
-// Client files
-app.use('/', clientsRouter)
+app.use('/', activityPubRouter)
+app.use('/', feedsRouter)
+app.use('/', webfingerRouter)
+app.use('/', trackerRouter)
+app.use('/', botsRouter)
 
 // Static files
 app.use('/', staticRouter)
+app.use('/', wellKnownRouter)
+app.use('/', miscRouter)
+app.use('/', downloadRouter)
+app.use('/', lazyStaticRouter)
+app.use('/', objectStorageProxyRouter)
 
-// Always serve index client page (the client is a single page application, let it handle routing)
-app.use('/*', function (req, res) {
-  if (req.accepts(ACCEPT_HEADERS) === 'html') {
-    return res.sendFile(path.join(__dirname, '../client/dist/index.html'))
-  }
-
-  return res.status(404).end()
-})
+// Client files, last valid routes!
+const cliOptions = cli.opts<{ client: boolean, plugins: boolean }>()
+if (cliOptions.client) app.use('/', clientsRouter)
 
 // ----------- Errors -----------
 
-// Catch 404 and forward to error handler
-app.use(function (req, res, next) {
-  const err = new Error('Not Found')
-  err['status'] = 404
-  next(err)
+// Catch unmatched routes
+app.use((_req, res: express.Response) => {
+  res.status(HttpStatusCode.NOT_FOUND_404).end()
 })
 
-app.use(function (err, req, res, next) {
+// Catch thrown errors
+app.use((err, _req, res: express.Response, _next) => {
+  // Format error to be logged
   let error = 'Unknown error.'
   if (err) {
     error = err.stack || err.message || err
   }
 
-  logger.error('Error in controller.', { error })
-  return res.status(err.status || 500).end()
+  // Handling Sequelize error traces
+  const sql = err?.parent ? err.parent.sql : undefined
+
+  // Help us to debug SequelizeConnectionAcquireTimeoutError errors
+  const activeRequests = err?.name === 'SequelizeConnectionAcquireTimeoutError' && typeof (process as any)._getActiveRequests !== 'function'
+    ? (process as any)._getActiveRequests()
+    : undefined
+
+  logger.error('Error in controller.', { err: error, sql, activeRequests })
+
+  return res.fail({
+    status: err.status || HttpStatusCode.INTERNAL_SERVER_ERROR_500,
+    message: err.message,
+    type: err.name
+  })
 })
 
+const server = createWebsocketTrackerServer(app)
+
 // ----------- Run -----------
 
-function onDatabaseInitDone () {
+async function startApplication () {
   const port = CONFIG.LISTEN.PORT
+  const hostname = CONFIG.LISTEN.HOSTNAME
 
-  installApplication()
-    .then(() => {
-      // ----------- Make the server listening -----------
-      server.listen(port, () => {
-        // Emailer initialization and then job queue initialization
-        Emailer.Instance.init()
-        Emailer.Instance.checkConnectionOrDie()
-          .then(() => JobQueue.Instance.init())
+  await installApplication()
 
-        // Caches initializations
-        VideosPreviewCache.Instance.init(CONFIG.CACHE.PREVIEWS.SIZE)
+  // Check activity pub urls are valid
+  checkActivityPubUrls()
+    .catch(err => {
+      logger.error('Error in ActivityPub URLs checker.', { err })
+      process.exit(-1)
+    })
 
-        // Enable Schedulers
-        BadActorFollowScheduler.Instance.enable()
-        RemoveOldJobsScheduler.Instance.enable()
+  checkFFmpegVersion()
+    .catch(err => logger.error('Cannot check ffmpeg version', { err }))
+
+  Redis.Instance.init()
+  Emailer.Instance.init()
+
+  await Promise.all([
+    Emailer.Instance.checkConnection(),
+    JobQueue.Instance.init(),
+    ServerConfigManager.Instance.init()
+  ])
+
+  // Caches initializations
+  VideosPreviewCache.Instance.init(CONFIG.CACHE.PREVIEWS.SIZE, FILES_CACHE.PREVIEWS.MAX_AGE)
+  VideosCaptionCache.Instance.init(CONFIG.CACHE.VIDEO_CAPTIONS.SIZE, FILES_CACHE.VIDEO_CAPTIONS.MAX_AGE)
+  VideosTorrentCache.Instance.init(CONFIG.CACHE.TORRENTS.SIZE, FILES_CACHE.TORRENTS.MAX_AGE)
+
+  // Enable Schedulers
+  ActorFollowScheduler.Instance.enable()
+  RemoveOldJobsScheduler.Instance.enable()
+  UpdateVideosScheduler.Instance.enable()
+  YoutubeDlUpdateScheduler.Instance.enable()
+  VideosRedundancyScheduler.Instance.enable()
+  RemoveOldHistoryScheduler.Instance.enable()
+  RemoveOldViewsScheduler.Instance.enable()
+  PluginsCheckScheduler.Instance.enable()
+  PeerTubeVersionCheckScheduler.Instance.enable()
+  AutoFollowIndexInstances.Instance.enable()
+  RemoveDanglingResumableUploadsScheduler.Instance.enable()
+  VideoChannelSyncLatestScheduler.Instance.enable()
+  VideoViewsBufferScheduler.Instance.enable()
+  GeoIPUpdateScheduler.Instance.enable()
+  OpenTelemetryMetrics.Instance.registerMetrics()
+
+  PluginManager.Instance.init(server)
+  // Before PeerTubeSocket init
+  PluginManager.Instance.registerWebSocketRouter()
+
+  PeerTubeSocket.Instance.init(server)
+  VideoViewsManager.Instance.init()
+
+  updateStreamingPlaylistsInfohashesIfNeeded()
+    .catch(err => logger.error('Cannot update streaming playlist infohashes.', { err }))
+
+  LiveManager.Instance.init()
+  if (CONFIG.LIVE.ENABLED) await LiveManager.Instance.run()
+
+  // Make server listening
+  server.listen(port, hostname, async () => {
+    if (cliOptions.plugins) {
+      try {
+        await PluginManager.Instance.rebuildNativePluginsIfNeeded()
+
+        await PluginManager.Instance.registerPluginsAndThemes()
+      } catch (err) {
+        logger.error('Cannot register plugins and themes.', { err })
+      }
+    }
 
-        // Redis initialization
-        Redis.Instance.init()
+    ApplicationModel.updateNodeVersions()
+      .catch(err => logger.error('Cannot update node versions.', { err }))
 
-        logger.info('Server listening on port %d', port)
-        logger.info('Web server: %s', CONFIG.WEBSERVER.URL)
+    JobQueue.Instance.start()
+      .catch(err => {
+        logger.error('Cannot start job queue.', { err })
+        process.exit(-1)
       })
-    })
+
+    logger.info('HTTP server listening on %s:%d', hostname, port)
+    logger.info('Web server: %s', WEBSERVER.URL)
+
+    Hooks.runAction('action:application.listening')
+
+    if (cliOptions['benchmarkStartup']) process.exit(0)
+  })
+
+  process.on('exit', () => {
+    JobQueue.Instance.terminate()
+      .catch(err => logger.error('Cannot terminate job queue.', { err }))
+  })
+
+  process.on('SIGINT', () => process.exit(0))
 }