X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Flib%2Ffriends.js;h=d81a603ad5267e4007cd139c6e54923ade9a8e36;hb=528a9efa8272532bbd0dafc35c3e05e57c50f61e;hp=e052574a545ca432b887adf321aebdf4e866becf;hpb=d6ea0175cbfc9995c3b2ec23866f7abafa9e3904;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/lib/friends.js b/server/lib/friends.js
index e052574a5..d81a603ad 100644
--- a/server/lib/friends.js
+++ b/server/lib/friends.js
@@ -24,15 +24,15 @@ const pods = {
   getMyCertificate: getMyCertificate,
   makeFriends: makeFriends,
   quitFriends: quitFriends,
-  removeVideoToFriends: removeVideoToFriends
+  removeVideoToFriends: removeVideoToFriends,
+  sendOwnedVideosToPod: sendOwnedVideosToPod
 }
 
 function addVideoToFriends (video) {
-  // To avoid duplicates
-  const id = video.name + video.magnetUri
   // ensure namePath is null
   video.namePath = null
-  requestsScheduler.addRequest(id, 'add', video)
+
+  requestsScheduler.addRequest('add', video)
 }
 
 function hasFriends (callback) {
@@ -60,7 +60,7 @@ function makeFriends (callback) {
 
     const urls = config.get('network.friends')
 
-    async.each(urls, function (url, callbackEach) {
+    async.eachSeries(urls, function (url, callbackEach) {
       computeForeignPodsList(url, podsScore, callbackEach)
     }, function (err) {
       if (err) return callback(err)
@@ -78,52 +78,92 @@ function quitFriends (callback) {
   // Stop pool requests
   requestsScheduler.deactivate()
   // Flush pool requests
-  requestsScheduler.forceSend()
+  requestsScheduler.flush()
+
+  async.waterfall([
+    function getPodsList (callbackAsync) {
+      return Pods.list(callbackAsync)
+    },
+
+    function announceIQuitMyFriends (pods, callbackAsync) {
+      const requestParams = {
+        method: 'POST',
+        path: '/api/' + constants.API_VERSION + '/pods/remove',
+        sign: true
+      }
 
-  Pods.list(function (err, pods) {
-    if (err) return callback(err)
+      // Announce we quit them
+      // We don't care if the request fails
+      // The other pod will exclude us automatically after a while
+      async.eachLimit(pods, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
+        requestParams.toPod = pod
+        requests.makeSecureRequest(requestParams, callbackEach)
+      }, function (err) {
+        if (err) {
+          logger.error('Some errors while quitting friends.', { err: err })
+          // Don't stop the process
+        }
 
-    const request = {
-      method: 'POST',
-      path: '/api/' + constants.API_VERSION + '/pods/remove',
-      sign: true,
-      encrypt: true,
-      data: {
-        url: 'me' // Fake data
-      }
-    }
+        return callbackAsync()
+      })
+    },
 
-    // Announce we quit them
-    requests.makeMultipleRetryRequest(request, pods, function () {
+    function removePodsFromDB (callbackAsync) {
       Pods.removeAll(function (err) {
-        requestsScheduler.activate()
-
-        if (err) return callback(err)
+        return callbackAsync(err)
+      })
+    },
 
-        logger.info('Broke friends, so sad :(')
+    function listRemoteVideos (callbackAsync) {
+      logger.info('Broke friends, so sad :(')
 
-        Videos.listFromRemotes(function (err, videosList) {
-          if (err) return callback(err)
+      Videos.listFromRemotes(callbackAsync)
+    },
 
-          videos.removeRemoteVideos(videosList, function (err) {
-            if (err) {
-              logger.error('Cannot remove remote videos.', { error: err })
-              return callback(err)
-            }
+    function removeTheRemoteVideos (videosList, callbackAsync) {
+      videos.removeRemoteVideos(videosList, function (err) {
+        if (err) {
+          logger.error('Cannot remove remote videos.', { error: err })
+          return callbackAsync(err)
+        }
 
-            logger.info('Removed all remote videos.')
-            callback(null)
-          })
-        })
+        return callbackAsync(null)
       })
-    })
+    }
+  ], function (err) {
+    // Don't forget to re activate the scheduler, even if there was an error
+    requestsScheduler.activate()
+
+    if (err) return callback(err)
+
+    logger.info('Removed all remote videos.')
+    return callback(null)
   })
 }
 
 function removeVideoToFriends (video) {
-  // To avoid duplicates
-  const id = video.name + video.magnetUri
-  requestsScheduler.addRequest(id, 'remove', video)
+  requestsScheduler.addRequest('remove', video)
+}
+
+function sendOwnedVideosToPod (podId) {
+  Videos.listOwned(function (err, videosList) {
+    if (err) {
+      logger.error('Cannot get the list of videos we own.')
+      return
+    }
+
+    videosList.forEach(function (video) {
+      videos.convertVideoToRemote(video, function (err, remoteVideo) {
+        if (err) {
+          logger.error('Cannot convert video to remote.', { error: err })
+          // Don't break the process
+          return
+        }
+
+        requestsScheduler.addRequestTo([ podId ], 'add', remoteVideo)
+      })
+    })
+  })
 }
 
 // ---------------------------------------------------------------------------
@@ -133,18 +173,19 @@ module.exports = pods
 // ---------------------------------------------------------------------------
 
 function computeForeignPodsList (url, podsScore, callback) {
-  // Let's give 1 point to the pod we ask the friends list
-  podsScore[url] = 1
-
   getForeignPodsList(url, function (err, foreignPodsList) {
     if (err) return callback(err)
-    if (foreignPodsList.length === 0) return callback()
+
+    if (!foreignPodsList) foreignPodsList = []
+
+    // Let's give 1 point to the pod we ask the friends list
+    foreignPodsList.push({ url: url })
 
     foreignPodsList.forEach(function (foreignPod) {
-      const foreignUrl = foreignPod.url
+      const foreignPodUrl = foreignPod.url
 
-      if (podsScore[foreignUrl]) podsScore[foreignUrl]++
-      else podsScore[foreignUrl] = 1
+      if (podsScore[foreignPodUrl]) podsScore[foreignPodUrl]++
+      else podsScore[foreignPodUrl] = 1
     })
 
     callback()
@@ -159,9 +200,7 @@ function computeWinningPods (urls, podsScore) {
   Object.keys(podsScore).forEach(function (pod) {
     if (podsScore[pod] > baseScore) podsList.push({ url: pod })
   })
-  console.log(urls)
-  console.log(podsScore)
-  console.log(podsList)
+
   return podsList
 }
 
@@ -181,61 +220,43 @@ function makeRequestsToWinningPods (cert, podsList, callback) {
   // Flush pool requests
   requestsScheduler.forceSend()
 
-  // Get the list of our videos to send to our new friends
-  Videos.listOwned(function (err, videosList) {
-    if (err) {
-      logger.error('Cannot get the list of videos we own.')
-      return callback(err)
-    }
-
-    const data = {
-      url: http + '://' + host + ':' + port,
-      publicKey: cert,
-      videos: videosList
+  async.eachLimit(podsList, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
+    const params = {
+      url: pod.url + '/api/' + constants.API_VERSION + '/pods/',
+      method: 'POST',
+      json: {
+        url: http + '://' + host + ':' + port,
+        publicKey: cert
+      }
     }
 
-    requests.makeMultipleRetryRequest(
-      { method: 'POST', path: '/api/' + constants.API_VERSION + '/pods/', data: data },
-
-      podsList,
-
-      function eachRequest (err, response, body, url, pod, callbackEachRequest) {
-        // We add the pod if it responded correctly with its public certificate
-        if (!err && response.statusCode === 200) {
-          Pods.add({ url: pod.url, publicKey: body.cert, score: constants.FRIEND_BASE_SCORE }, function (err) {
-            if (err) {
-              logger.error('Error with adding %s pod.', pod.url, { error: err })
-              return callbackEachRequest()
-            }
-
-            videos.createRemoteVideos(body.videos, function (err) {
-              if (err) {
-                logger.error('Error with adding videos of pod.', pod.url, { error: err })
-                return callbackEachRequest()
-              }
-
-              logger.debug('Adding remote videos from %s.', pod.url, { videos: body.videos })
-              return callbackEachRequest()
-            })
-          })
-        } else {
-          logger.error('Error with adding %s pod.', pod.url, { error: err || new Error('Status not 200') })
-          return callbackEachRequest()
-        }
-      },
+    requests.makeRetryRequest(params, function (err, res, body) {
+      if (err) {
+        logger.error('Error with adding %s pod.', pod.url, { error: err })
+        // Don't break the process
+        return callbackEach()
+      }
 
-      function endRequests (err) {
-        // Now we made new friends, we can re activate the pool of requests
-        requestsScheduler.activate()
+      if (res.statusCode === 200) {
+        Pods.add({ url: pod.url, publicKey: body.cert, score: constants.FRIEND_BASE_SCORE }, function (err, podCreated) {
+          if (err) logger.error('Cannot add friend %s pod.', pod.url)
 
-        if (err) {
-          logger.error('There was some errors when we wanted to make friends.')
-          return callback(err)
-        }
+          // Add our videos to the request scheduler
+          sendOwnedVideosToPod(podCreated._id)
 
-        logger.debug('makeRequestsToWinningPods finished.')
-        return callback(null)
+          return callbackEach()
+        })
+      } else {
+        logger.error('Status not 200 for %s pod.', pod.url)
+        return callbackEach()
       }
-    )
+    })
+  }, function endRequests () {
+    // Final callback, we've ended all the requests
+    // Now we made new friends, we can re activate the pool of requests
+    requestsScheduler.activate()
+
+    logger.debug('makeRequestsToWinningPods finished.')
+    return callback()
   })
 }