X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Frequest.js;h=baa26fc1b2576f7919df03291007cc7bd72a5a2d;hb=1e4b0080ff1b4e802f71ec1f4cbf8cbcc70cdcbd;hp=1d60380449014dbdd5a1f65358ae614569077adc;hpb=ed04d94f6d7132055f97a2f757b85c03c5f2a0b6;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/models/request.js b/server/models/request.js
index 1d6038044..baa26fc1b 100644
--- a/server/models/request.js
+++ b/server/models/request.js
@@ -118,13 +118,8 @@ function makeRequest (toPod, requestEndpoint, requestsToMake, callback) {
   // The function fire some useful callbacks
   requests.makeSecureRequest(params, function (err, res) {
     if (err || (res.statusCode !== 200 && res.statusCode !== 201 && res.statusCode !== 204)) {
-      logger.error(
-        'Error sending secure request to %s pod.',
-        toPod.host,
-        {
-          error: err ? err.message : 'Status code not 20x : ' + res.statusCode
-        }
-      )
+      err = err ? err.message : 'Status code not 20x : ' + res.statusCode
+      logger.error('Error sending secure request to %s pod.', toPod.host, { error: err })
 
       return callback(false)
     }
@@ -138,9 +133,9 @@ function makeRequests () {
   const self = this
   const RequestToPod = this.sequelize.models.RequestToPod
 
-  // We limit the size of the requests (REQUESTS_LIMIT)
+  // We limit the size of the requests
   // We don't want to stuck with the same failing requests so we get a random list
-  listWithLimitAndRandom.call(self, constants.REQUESTS_LIMIT, function (err, requests) {
+  listWithLimitAndRandom.call(self, constants.REQUESTS_LIMIT_PODS, constants.REQUESTS_LIMIT_PER_POD, function (err, requests) {
     if (err) {
       logger.error('Cannot get the list of requests.', { err: err })
       return // Abort
@@ -152,63 +147,37 @@ function makeRequests () {
       return
     }
 
-    logger.info('Making requests to friends.')
-
     // We want to group requests by destinations pod and endpoint
-    const requestsToMakeGrouped = {}
-
-    requests.forEach(function (request) {
-      request.Pods.forEach(function (toPod) {
-        const hashKey = toPod.id + request.endpoint
-        if (!requestsToMakeGrouped[hashKey]) {
-          requestsToMakeGrouped[hashKey] = {
-            toPodId: toPod.id,
-            endpoint: request.endpoint,
-            ids: [], // request ids, to delete them from the DB in the future
-            datas: [] // requests data,
-          }
-        }
+    const requestsToMakeGrouped = buildRequestObjects(requests)
 
-        requestsToMakeGrouped[hashKey].ids.push(request.id)
-        requestsToMakeGrouped[hashKey].datas.push(request.request)
-      })
-    })
+    logger.info('Making requests to friends.')
 
     const goodPods = []
     const badPods = []
 
     eachLimit(Object.keys(requestsToMakeGrouped), constants.REQUESTS_IN_PARALLEL, function (hashKey, callbackEach) {
       const requestToMake = requestsToMakeGrouped[hashKey]
+      const toPod = requestToMake.toPod
 
-      // FIXME: SQL request inside a loop :/
-      self.sequelize.models.Pod.load(requestToMake.toPodId, function (err, toPod) {
-        if (err) {
-          logger.error('Error finding pod by id.', { err: err })
-          return callbackEach()
-        }
+      // Maybe the pod is not our friend anymore so simply remove it
+      if (!toPod) {
+        const requestIdsToDelete = requestToMake.ids
 
-        // Maybe the pod is not our friend anymore so simply remove it
-        if (!toPod) {
-          const requestIdsToDelete = requestToMake.ids
+        logger.info('Removing %d requests of unexisting pod %s.', requestIdsToDelete.length, requestToMake.toPod.id)
+        return RequestToPod.removePodOf(requestIdsToDelete, requestToMake.toPod.id, callbackEach)
+      }
 
-          logger.info('Removing %d requests of unexisting pod %s.', requestIdsToDelete.length, requestToMake.toPodId)
-          RequestToPod.removePodOf.call(self, requestIdsToDelete, requestToMake.toPodId)
+      makeRequest(toPod, requestToMake.endpoint, requestToMake.datas, function (success) {
+        if (success === false) {
+          badPods.push(requestToMake.toPod.id)
           return callbackEach()
         }
 
-        makeRequest(toPod, requestToMake.endpoint, requestToMake.datas, function (success) {
-          if (success === true) {
-            logger.debug('Removing requests for pod %s.', requestToMake.toPodId, { requestsIds: requestToMake.ids })
+        logger.debug('Removing requests for pod %s.', requestToMake.toPod.id, { requestsIds: requestToMake.ids })
+        goodPods.push(requestToMake.toPod.id)
 
-            goodPods.push(requestToMake.toPodId)
-
-            // Remove the pod id of these request ids
-            RequestToPod.removePodOf(requestToMake.ids, requestToMake.toPodId, callbackEach)
-          } else {
-            badPods.push(requestToMake.toPodId)
-            callbackEach()
-          }
-        })
+        // Remove the pod id of these request ids
+        RequestToPod.removePodOf(requestToMake.ids, requestToMake.toPod.id, callbackEach)
       })
     }, function () {
       // All the requests were made, we update the pods score
@@ -221,6 +190,32 @@ function makeRequests () {
   })
 }
 
+function buildRequestObjects (requests) {
+  const requestsToMakeGrouped = {}
+
+  Object.keys(requests).forEach(function (toPodId) {
+    requests[toPodId].forEach(function (data) {
+      const request = data.request
+      const pod = data.pod
+      const hashKey = toPodId + request.endpoint
+
+      if (!requestsToMakeGrouped[hashKey]) {
+        requestsToMakeGrouped[hashKey] = {
+          toPod: pod,
+          endpoint: request.endpoint,
+          ids: [], // request ids, to delete them from the DB in the future
+          datas: [] // requests data,
+        }
+      }
+
+      requestsToMakeGrouped[hashKey].ids.push(request.id)
+      requestsToMakeGrouped[hashKey].datas.push(request.request)
+    })
+  })
+
+  return requestsToMakeGrouped
+}
+
 // Remove pods with a score of 0 (too many requests where they were unreachable)
 function removeBadPods () {
   const self = this
@@ -275,29 +270,60 @@ function updatePodsScore (goodPods, badPods) {
   }
 }
 
-function listWithLimitAndRandom (limit, callback) {
+function listWithLimitAndRandom (limitPods, limitRequestsPerPod, callback) {
   const self = this
+  const Pod = this.sequelize.models.Pod
 
-  self.count().asCallback(function (err, count) {
+  Pod.listRandomPodIdsWithRequest(limitPods, function (err, podIds) {
     if (err) return callback(err)
 
-    // Optimization...
-    if (count === 0) return callback(null, [])
-
-    let start = Math.floor(Math.random() * count) - limit
-    if (start < 0) start = 0
+    // We don't have friends that have requests
+    if (podIds.length === 0) return callback(null, [])
 
+    // The the first x requests of these pods
+    // It is very important to sort by id ASC to keep the requests order!
     const query = {
       order: [
         [ 'id', 'ASC' ]
       ],
-      // offset: start,
-      // limit: limit,
-      include: [ this.sequelize.models.Pod ]
+      include: [
+        {
+          model: self.sequelize.models.Pod,
+          where: {
+            id: {
+              $in: podIds
+            }
+          }
+        }
+      ]
     }
 
-    self.findAll(query).asCallback(callback)
+    self.findAll(query).asCallback(function (err, requests) {
+      if (err) return callback(err)
+
+      const requestsGrouped = groupAndTruncateRequests(requests, limitRequestsPerPod)
+      return callback(err, requestsGrouped)
+    })
+  })
+}
+
+function groupAndTruncateRequests (requests, limitRequestsPerPod) {
+  const requestsGrouped = {}
+
+  requests.forEach(function (request) {
+    request.Pods.forEach(function (pod) {
+      if (!requestsGrouped[pod.id]) requestsGrouped[pod.id] = []
+
+      if (requestsGrouped[pod.id].length < limitRequestsPerPod) {
+        requestsGrouped[pod.id].push({
+          request,
+          pod
+        })
+      }
+    })
   })
+
+  return requestsGrouped
 }
 
 function removeAll (callback) {