'use strict'
-var async = require('async')
-var config = require('config')
-var fs = require('fs')
-var request = require('request')
-
-var constants = require('../initializers/constants')
-var logger = require('../helpers/logger')
-var peertubeCrypto = require('../helpers/peertubeCrypto')
-var Pods = require('../models/pods')
-var poolRequests = require('../lib/poolRequests')
-var requests = require('../helpers/requests')
-var Videos = require('../models/videos')
-
-var http = config.get('webserver.https') ? 'https' : 'http'
-var host = config.get('webserver.host')
-var port = config.get('webserver.port')
-
-var pods = {
+const async = require('async')
+const config = require('config')
+const fs = require('fs')
+const request = require('request')
+
+const constants = require('../initializers/constants')
+const logger = require('../helpers/logger')
+const peertubeCrypto = require('../helpers/peertubeCrypto')
+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 pods = {
addVideoToFriends: addVideoToFriends,
hasFriends: hasFriends,
+ getMyCertificate: getMyCertificate,
makeFriends: makeFriends,
quitFriends: quitFriends,
removeVideoToFriends: removeVideoToFriends
function addVideoToFriends (video) {
// To avoid duplicates
- var id = video.name + video.magnetUri
+ const id = video.name + video.magnetUri
// ensure namePath is null
video.namePath = null
- poolRequests.addRequest(id, 'add', video)
+ requestsScheduler.addRequest(id, 'add', video)
}
function hasFriends (callback) {
Pods.count(function (err, count) {
if (err) return callback(err)
- var has_friends = (count !== 0)
- callback(null, has_friends)
+ const hasFriends = (count !== 0)
+ callback(null, hasFriends)
})
}
+function getMyCertificate (callback) {
+ fs.readFile(peertubeCrypto.getCertDir() + 'peertube.pub', 'utf8', callback)
+}
+
function makeFriends (callback) {
- var pods_score = {}
+ const podsScore = {}
logger.info('Make friends!')
- fs.readFile(peertubeCrypto.getCertDir() + 'peertube.pub', 'utf8', function (err, cert) {
+ getMyCertificate(function (err, cert) {
if (err) {
logger.error('Cannot read public cert.')
return callback(err)
}
- var urls = config.get('network.friends')
+ const urls = config.get('network.friends')
- async.each(urls, function (url, callback) {
- computeForeignPodsList(url, pods_score, callback)
+ async.each(urls, function (url, callbackEach) {
+ computeForeignPodsList(url, podsScore, callbackEach)
}, function (err) {
if (err) return callback(err)
- logger.debug('Pods scores computed.', { pods_score: pods_score })
- var pods_list = computeWinningPods(urls, pods_score)
- logger.debug('Pods that we keep computed.', { pods_to_keep: pods_list })
+ logger.debug('Pods scores computed.', { podsScore: podsScore })
+ const podsList = computeWinningPods(urls, podsScore)
+ logger.debug('Pods that we keep.', { podsToKeep: podsList })
- makeRequestsToWinningPods(cert, pods_list, callback)
+ makeRequestsToWinningPods(cert, podsList, callback)
})
})
}
function quitFriends (callback) {
// Stop pool requests
- poolRequests.deactivate()
+ requestsScheduler.deactivate()
// Flush pool requests
- poolRequests.forceSend()
+ requestsScheduler.forceSend()
Pods.list(function (err, pods) {
if (err) return callback(err)
- var request = {
+ const request = {
method: 'POST',
path: '/api/' + constants.API_VERSION + '/pods/remove',
sign: true,
// Announce we quit them
requests.makeMultipleRetryRequest(request, pods, function () {
Pods.removeAll(function (err) {
- poolRequests.activate()
+ requestsScheduler.activate()
if (err) return callback(err)
logger.info('Broke friends, so sad :(')
- Videos.removeAllRemotes(function (err) {
+ Videos.listFromRemotes(function (err, videosList) {
if (err) return callback(err)
- logger.info('Removed all remote videos.')
- callback(null)
+ videos.removeRemoteVideos(videosList, function (err) {
+ if (err) {
+ logger.error('Cannot remove remote videos.', { error: err })
+ return callback(err)
+ }
+
+ logger.info('Removed all remote videos.')
+ callback(null)
+ })
})
})
})
function removeVideoToFriends (video) {
// To avoid duplicates
- var id = video.name + video.magnetUri
- poolRequests.addRequest(id, 'remove', video)
+ const id = video.name + video.magnetUri
+ requestsScheduler.addRequest(id, 'remove', video)
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
-function computeForeignPodsList (url, pods_score, callback) {
+function computeForeignPodsList (url, podsScore, callback) {
// Let's give 1 point to the pod we ask the friends list
- pods_score[url] = 1
+ podsScore[url] = 1
- getForeignPodsList(url, function (err, foreign_pods_list) {
+ getForeignPodsList(url, function (err, foreignPodsList) {
if (err) return callback(err)
- if (foreign_pods_list.length === 0) return callback()
+ if (foreignPodsList.length === 0) return callback()
- async.each(foreign_pods_list, function (foreign_pod, callback_each) {
- var foreign_url = foreign_pod.url
+ foreignPodsList.forEach(function (foreignPod) {
+ const foreignUrl = foreignPod.url
- if (pods_score[foreign_url]) pods_score[foreign_url]++
- else pods_score[foreign_url] = 1
-
- callback_each()
- }, function () {
- callback()
+ if (podsScore[foreignUrl]) podsScore[foreignUrl]++
+ else podsScore[foreignUrl] = 1
})
+
+ callback()
})
}
-function computeWinningPods (urls, pods_score) {
+function computeWinningPods (urls, podsScore) {
// Build the list of pods to add
// Only add a pod if it exists in more than a half base pods
- var pods_list = []
- var base_score = urls.length / 2
- Object.keys(pods_score).forEach(function (pod) {
- if (pods_score[pod] > base_score) pods_list.push({ url: pod })
+ const podsList = []
+ const baseScore = urls.length / 2
+ Object.keys(baseScore).forEach(function (pod) {
+ if (podsScore[pod] > baseScore) podsList.push({ url: pod })
})
- return pods_list
+ return podsList
}
function getForeignPodsList (url, callback) {
- var path = '/api/' + constants.API_VERSION + '/pods'
+ const path = '/api/' + constants.API_VERSION + '/pods'
request.get(url + path, function (err, response, body) {
if (err) return callback(err)
})
}
-function makeRequestsToWinningPods (cert, pods_list, callback) {
+function makeRequestsToWinningPods (cert, podsList, callback) {
// Stop pool requests
- poolRequests.deactivate()
+ requestsScheduler.deactivate()
// Flush pool requests
- poolRequests.forceSend()
+ requestsScheduler.forceSend()
// Get the list of our videos to send to our new friends
- Videos.listOwned(function (err, videos_list) {
+ Videos.listOwned(function (err, videosList) {
if (err) {
logger.error('Cannot get the list of videos we own.')
return callback(err)
}
- var data = {
+ const data = {
url: http + '://' + host + ':' + port,
publicKey: cert,
- videos: videos_list
+ videos: videosList
}
requests.makeMultipleRetryRequest(
{ method: 'POST', path: '/api/' + constants.API_VERSION + '/pods/', data: data },
- pods_list,
+ podsList,
- function eachRequest (err, response, body, url, pod, callback_each_request) {
+ 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 callback_each_request()
+ return callbackEachRequest()
}
- Videos.addRemotes(body.videos, function (err) {
+ videos.createRemoteVideos(body.videos, function (err) {
if (err) {
logger.error('Error with adding videos of pod.', pod.url, { error: err })
- return callback_each_request()
+ return callbackEachRequest()
}
logger.debug('Adding remote videos from %s.', pod.url, { videos: body.videos })
- return callback_each_request()
+ return callbackEachRequest()
})
})
} else {
logger.error('Error with adding %s pod.', pod.url, { error: err || new Error('Status not 200') })
- return callback_each_request()
+ return callbackEachRequest()
}
},
function endRequests (err) {
// Now we made new friends, we can re activate the pool of requests
- poolRequests.activate()
+ requestsScheduler.activate()
if (err) {
logger.error('There was some errors when we wanted to make friends.')