PeerTube/server/lib/friends.js

277 lines
7.2 KiB
JavaScript
Raw Normal View History

'use strict'
2016-07-18 17:17:52 +02:00
const each = require('async/each')
const eachLimit = require('async/eachLimit')
const eachSeries = require('async/eachSeries')
2016-03-16 22:29:27 +01:00
const fs = require('fs')
const mongoose = require('mongoose')
2016-03-16 22:29:27 +01:00
const request = require('request')
2016-07-18 17:17:52 +02:00
const waterfall = require('async/waterfall')
2016-03-16 22:29:27 +01:00
const constants = require('../initializers/constants')
const logger = require('../helpers/logger')
const requests = require('../helpers/requests')
const Pod = mongoose.model('Pod')
const Request = mongoose.model('Request')
const Video = mongoose.model('Video')
2016-03-16 22:29:27 +01:00
const friends = {
addVideoToFriends: addVideoToFriends,
hasFriends: hasFriends,
getMyCertificate: getMyCertificate,
makeFriends: makeFriends,
quitFriends: quitFriends,
removeVideoToFriends: removeVideoToFriends,
sendOwnedVideosToPod: sendOwnedVideosToPod
}
function addVideoToFriends (video) {
createRequest('add', video)
}
function hasFriends (callback) {
Pod.countAll(function (err, count) {
if (err) return callback(err)
const hasFriends = (count !== 0)
callback(null, hasFriends)
})
}
function getMyCertificate (callback) {
2016-08-19 21:34:51 +02:00
fs.readFile(constants.CONFIG.STORAGE.CERT_DIR + 'peertube.pub', 'utf8', callback)
}
function makeFriends (urls, callback) {
const podsScore = {}
logger.info('Make friends!')
getMyCertificate(function (err, cert) {
if (err) {
logger.error('Cannot read public cert.')
return callback(err)
}
2016-02-04 21:10:33 +01:00
2016-07-18 17:17:52 +02:00
eachSeries(urls, function (url, callbackEach) {
computeForeignPodsList(url, podsScore, callbackEach)
}, function (err) {
2016-02-04 21:10:33 +01:00
if (err) return callback(err)
logger.debug('Pods scores computed.', { podsScore: podsScore })
const podsList = computeWinningPods(urls, podsScore)
logger.debug('Pods that we keep.', { podsToKeep: podsList })
makeRequestsToWinningPods(cert, podsList, callback)
2016-02-04 21:10:33 +01:00
})
})
}
function quitFriends (callback) {
// Stop pool requests
Request.deactivate()
// Flush pool requests
Request.flush()
2016-07-18 17:17:52 +02:00
waterfall([
function getPodsList (callbackAsync) {
return Pod.list(callbackAsync)
},
function announceIQuitMyFriends (pods, callbackAsync) {
const requestParams = {
method: 'POST',
path: '/api/' + constants.API_VERSION + '/pods/remove',
sign: true
2016-02-04 21:10:33 +01:00
}
// Announce we quit them
// We don't care if the request fails
// The other pod will exclude us automatically after a while
2016-07-18 17:17:52 +02:00
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
}
return callbackAsync()
})
},
2016-02-04 21:10:33 +01:00
function removePodsFromDB (callbackAsync) {
Pod.removeAll(function (err) {
return callbackAsync(err)
})
},
2016-02-04 21:10:33 +01:00
function listRemoteVideos (callbackAsync) {
logger.info('Broke friends, so sad :(')
2016-02-04 21:10:33 +01:00
Video.listRemotes(callbackAsync)
},
2016-02-04 21:10:33 +01:00
function removeTheRemoteVideos (videosList, callbackAsync) {
2016-07-18 17:17:52 +02:00
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
Request.activate()
if (err) return callback(err)
logger.info('Removed all remote videos.')
return callback(null)
})
}
2016-02-04 21:10:33 +01:00
function removeVideoToFriends (videoParams) {
createRequest('remove', videoParams)
}
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
}
createRequest('add', remoteVideo, [ podId ])
})
})
})
}
2016-02-04 21:10:33 +01:00
// ---------------------------------------------------------------------------
2016-02-04 21:10:33 +01:00
module.exports = friends
2016-02-04 21:10:33 +01:00
// ---------------------------------------------------------------------------
2016-02-04 21:10:33 +01:00
function computeForeignPodsList (url, podsScore, callback) {
getForeignPodsList(url, function (err, foreignPodsList) {
if (err) return callback(err)
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 foreignPodUrl = foreignPod.url
if (podsScore[foreignPodUrl]) podsScore[foreignPodUrl]++
else podsScore[foreignPodUrl] = 1
})
callback()
})
}
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
const podsList = []
const baseScore = urls.length / 2
2016-05-13 15:02:51 +02:00
Object.keys(podsScore).forEach(function (pod) {
if (podsScore[pod] > baseScore) podsList.push({ url: pod })
})
return podsList
}
function getForeignPodsList (url, callback) {
2016-03-16 22:29:27 +01:00
const path = '/api/' + constants.API_VERSION + '/pods'
2016-02-04 21:10:33 +01:00
request.get(url + path, function (err, response, body) {
if (err) return callback(err)
2016-02-05 19:02:05 +01:00
2016-08-23 14:37:36 +02:00
try {
const json = JSON.parse(body)
return callback(null, json)
} catch (err) {
return callback(err)
}
})
}
function makeRequestsToWinningPods (cert, podsList, callback) {
// Stop pool requests
Request.deactivate()
// Flush pool requests
Request.forceSend()
2016-07-18 17:17:52 +02:00
eachLimit(podsList, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
const params = {
url: pod.url + '/api/' + constants.API_VERSION + '/pods/',
method: 'POST',
json: {
2016-08-19 21:34:51 +02:00
url: constants.CONFIG.WEBSERVER.URL,
publicKey: cert
}
}
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()
}
if (res.statusCode === 200) {
const podObj = new Pod({ url: pod.url, publicKey: body.cert })
podObj.save(function (err, podCreated) {
if (err) {
logger.error('Cannot add friend %s pod.', pod.url, { error: err })
return callbackEach()
}
// Add our videos to the request scheduler
sendOwnedVideosToPod(podCreated._id)
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
Request.activate()
logger.debug('makeRequestsToWinningPods finished.')
return callback()
})
}
function createRequest (type, data, to) {
const req = new Request({
request: {
type: type,
data: data
}
})
if (to) {
req.to = to
}
req.save(function (err) {
if (err) logger.error('Cannot save the request.', { error: err })
})
}