const async = require('async')
const config = require('config')
const fs = require('fs')
+const mongoose = require('mongoose')
const request = require('request')
const constants = require('../initializers/constants')
const Pods = require('../models/pods')
const requestsScheduler = require('../lib/requestsScheduler')
const requests = require('../helpers/requests')
-const videos = require('../lib/videos')
-const Videos = require('../models/videos')
const http = config.get('webserver.https') ? 'https' : 'http'
const host = config.get('webserver.host')
const port = config.get('webserver.port')
+const Video = mongoose.model('Video')
const pods = {
addVideoToFriends: addVideoToFriends,
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) {
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)
// 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()
+ return callbackAsync(err)
+ })
+ },
- if (err) return callback(err)
+ function listRemoteVideos (callbackAsync) {
+ logger.info('Broke friends, so sad :(')
- logger.info('Broke friends, so sad :(')
+ Video.listRemotes(callbackAsync)
+ },
- Videos.listFromRemotes(function (err, videosList) {
- if (err) return callback(err)
+ function removeTheRemoteVideos (videosList, callbackAsync) {
+ async.each(videosList, function (video, callbackEach) {
+ video.remove(callbackEach)
+ }, callbackAsync)
+ }
+ ], function (err) {
+ // Don't forget to re activate the scheduler, even if there was an error
+ requestsScheduler.activate()
- videos.removeRemoteVideos(videosList, function (err) {
- if (err) {
- logger.error('Cannot remove remote videos.', { error: err })
- return callback(err)
- }
+ if (err) return callback(err)
- logger.info('Removed all remote videos.')
- callback(null)
- })
- })
- })
- })
+ 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) {
+ Video.listOwned(function (err, videosList) {
+ if (err) {
+ logger.error('Cannot get the list of videos we own.')
+ return
+ }
+
+ videosList.forEach(function (video) {
+ video.toRemoteJSON(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)
+ })
+ })
+ })
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
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()
// Only add a pod if it exists in more than a half base pods
const podsList = []
const baseScore = urls.length / 2
- Object.keys(baseScore).forEach(function (pod) {
+ Object.keys(podsScore).forEach(function (pod) {
if (podsScore[pod] > baseScore) podsList.push({ url: pod })
})
// 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()
})
}
projects / github / Chocobozzz / PeerTube.git / blobdiff