Add minimum bitrate limit

[github/Chocobozzz/PeerTube.git] / server / helpers / requests.ts

diff --git a/server/helpers/requests.ts b/server/helpers/requests.ts
index aee8f66736e956bc677ca2991ac0bfd79c2db3ff..57299eee137c256d7a118c3a7fe98bb69ac1b105 100644 (file)
--- a/server/helpers/requests.ts
+++ b/server/helpers/requests.ts
@@ -1,13 +1,20 @@
 import { createWriteStream, remove } from 'fs-extra'
-import got, { CancelableRequest, Options as GotOptions } from 'got'
+import got, { CancelableRequest, Options as GotOptions, RequestError, Response } from 'got'
+import { HttpProxyAgent, HttpsProxyAgent } from 'hpagent'
 import { join } from 'path'
 import { CONFIG } from '../initializers/config'
-import { ACTIVITY_PUB, PEERTUBE_VERSION, WEBSERVER } from '../initializers/constants'
+import { ACTIVITY_PUB, BINARY_CONTENT_TYPES, PEERTUBE_VERSION, REQUEST_TIMEOUT, WEBSERVER } from '../initializers/constants'
 import { pipelinePromise } from './core-utils'
 import { processImage } from './image-utils'
 import { logger } from './logger'
+import { getProxy, isProxyEnabled } from './proxy'
 
-const httpSignature = require('http-signature')
+const httpSignature = require('@peertube/http-signature')
+
+export interface PeerTubeRequestError extends Error {
+  statusCode?: number
+  responseBody?: any
+}
 
 type PeerTubeRequestOptions = {
   activityPub?: boolean
@@ -23,6 +30,8 @@ type PeerTubeRequestOptions = {
 } & Pick<GotOptions, 'headers' | 'json' | 'method' | 'searchParams'>
 
 const peertubeGot = got.extend({
+  ...getAgent(),
+
   headers: {
     'user-agent': getUserAgent()
   },
@@ -143,17 +152,58 @@ async function downloadImage (url: string, destDir: string, destName: string, si
   }
 }
 
+function getAgent () {
+  if (!isProxyEnabled()) return {}
+
+  const proxy = getProxy()
+
+  logger.info('Using proxy %s.', proxy)
+
+  const proxyAgentOptions = {
+    keepAlive: true,
+    keepAliveMsecs: 1000,
+    maxSockets: 256,
+    maxFreeSockets: 256,
+    scheduling: 'lifo' as 'lifo',
+    proxy
+  }
+
+  return {
+    agent: {
+      http: new HttpProxyAgent(proxyAgentOptions),
+      https: new HttpsProxyAgent(proxyAgentOptions)
+    }
+  }
+}
+
 function getUserAgent () {
   return `PeerTube/${PEERTUBE_VERSION} (+${WEBSERVER.URL})`
 }
 
+function isBinaryResponse (result: Response<any>) {
+  return BINARY_CONTENT_TYPES.has(result.headers['content-type'])
+}
+
+async function findLatestRedirection (url: string, options: PeerTubeRequestOptions, iteration = 1) {
+  if (iteration > 10) throw new Error('Too much iterations to find final URL ' + url)
+
+  const { headers } = await peertubeGot(url, { followRedirect: false, ...buildGotOptions(options) })
+
+  if (headers.location) return findLatestRedirection(headers.location, options, iteration + 1)
+
+  return url
+}
+
 // ---------------------------------------------------------------------------
 
 export {
   doRequest,
   doJSONRequest,
   doRequestAndSaveToFile,
-  downloadImage
+  isBinaryResponse,
+  downloadImage,
+  findLatestRedirection,
+  peertubeGot
 }
 
 // ---------------------------------------------------------------------------
@@ -165,14 +215,18 @@ function buildGotOptions (options: PeerTubeRequestOptions) {
 
   let headers = options.headers || {}
 
-  headers = { ...headers, date: new Date().toUTCString() }
+  if (!headers.date) {
+    headers = { ...headers, date: new Date().toUTCString() }
+  }
 
-  if (activityPub) {
+  if (activityPub && !headers.accept) {
     headers = { ...headers, accept: ACTIVITY_PUB.ACCEPT_HEADER }
   }
 
   return {
     method: options.method,
+    dnsCache: true,
+    timeout: REQUEST_TIMEOUT,
     json: options.json,
     searchParams: options.searchParams,
     headers,
@@ -180,14 +234,15 @@ function buildGotOptions (options: PeerTubeRequestOptions) {
   }
 }
 
-function buildRequestError (error: any) {
-  const newError = new Error(error.message)
+function buildRequestError (error: RequestError) {
+  const newError: PeerTubeRequestError = new Error(error.message)
   newError.name = error.name
   newError.stack = error.stack
 
-  if (error.response?.body) {
-    error.responseBody = error.response.body
+  if (error.response) {
+    newError.responseBody = error.response.body
+    newError.statusCode = error.response.statusCode
   }
 
-  return error
+  return newError
 }