PeerTube/server/lib/friends.js

344 lines
9.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 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')
2016-12-11 21:50:51 +01:00
const db = require('../initializers/database')
2016-03-16 22:29:27 +01:00
const logger = require('../helpers/logger')
2017-01-17 21:42:47 +01:00
const peertubeCrypto = require('../helpers/peertube-crypto')
2016-03-16 22:29:27 +01:00
const requests = require('../helpers/requests')
const ENDPOINT_ACTIONS = constants.REQUEST_ENDPOINT_ACTIONS[constants.REQUEST_ENDPOINTS.VIDEOS]
const friends = {
addVideoToFriends,
2016-12-29 19:07:05 +01:00
updateVideoToFriends,
2017-01-04 20:59:23 +01:00
reportAbuseVideoToFriend,
hasFriends,
makeFriends,
quitFriends,
removeVideoToFriends,
sendOwnedVideosToPod
}
function addVideoToFriends (videoData, transaction, callback) {
const options = {
type: ENDPOINT_ACTIONS.ADD,
endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
data: videoData,
transaction
}
createRequest(options, callback)
}
function updateVideoToFriends (videoData, transaction, callback) {
const options = {
type: ENDPOINT_ACTIONS.UPDATE,
endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
data: videoData,
transaction
}
createRequest(options, callback)
2017-01-04 20:59:23 +01:00
}
function removeVideoToFriends (videoParams) {
const options = {
type: ENDPOINT_ACTIONS.REMOVE,
endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
data: videoParams
}
createRequest(options)
2017-01-04 20:59:23 +01:00
}
function reportAbuseVideoToFriend (reportData, video) {
2017-01-10 22:24:42 +01:00
const options = {
type: ENDPOINT_ACTIONS.REPORT_ABUSE,
2017-01-10 22:24:42 +01:00
endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
data: reportData,
toIds: [ video.Author.podId ]
}
createRequest(options)
2016-12-29 19:07:05 +01:00
}
function hasFriends (callback) {
2016-12-11 21:50:51 +01:00
db.Pod.countAll(function (err, count) {
if (err) return callback(err)
const hasFriends = (count !== 0)
callback(null, hasFriends)
})
}
function makeFriends (hosts, callback) {
const podsScore = {}
logger.info('Make friends!')
2017-01-17 21:42:47 +01:00
peertubeCrypto.getMyPublicCert(function (err, cert) {
if (err) {
logger.error('Cannot read public cert.')
return callback(err)
}
2016-02-04 21:10:33 +01:00
eachSeries(hosts, function (host, callbackEach) {
computeForeignPodsList(host, 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(hosts, 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
2016-12-11 21:50:51 +01:00
db.Request.deactivate()
2016-07-18 17:17:52 +02:00
waterfall([
2016-12-24 16:59:17 +01:00
function flushRequests (callbackAsync) {
db.Request.flush(callbackAsync)
},
function getPodsList (callbackAsync) {
2016-12-11 21:50:51 +01:00
return db.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
}
2016-10-21 11:20:45 +02:00
return callbackAsync(null, pods)
})
},
2016-02-04 21:10:33 +01:00
2016-10-21 11:20:45 +02:00
function removePodsFromDB (pods, callbackAsync) {
each(pods, function (pod, callbackEach) {
2016-12-11 21:50:51 +01:00
pod.destroy().asCallback(callbackEach)
}, callbackAsync)
}
], function (err) {
// Don't forget to re activate the scheduler, even if there was an error
2016-12-11 21:50:51 +01:00
db.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 sendOwnedVideosToPod (podId) {
2016-12-24 16:59:17 +01:00
db.Video.listOwnedAndPopulateAuthorAndTags(function (err, videosList) {
if (err) {
logger.error('Cannot get the list of videos we own.')
return
}
videosList.forEach(function (video) {
2016-12-29 19:07:05 +01:00
video.toAddRemoteJSON(function (err, remoteVideo) {
if (err) {
logger.error('Cannot convert video to remote.', { error: err })
// Don't break the process
return
}
2017-01-10 22:24:42 +01:00
const options = {
type: 'add',
endpoint: constants.REQUEST_ENDPOINTS.VIDEOS,
data: remoteVideo,
toIds: [ podId ]
}
createRequest(options)
})
})
})
}
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 (host, podsScore, callback) {
2017-01-04 20:59:23 +01:00
getForeignPodsList(host, function (err, res) {
if (err) return callback(err)
2017-01-04 20:59:23 +01:00
const foreignPodsList = res.data
// Let's give 1 point to the pod we ask the friends list
foreignPodsList.push({ host })
foreignPodsList.forEach(function (foreignPod) {
const foreignPodHost = foreignPod.host
if (podsScore[foreignPodHost]) podsScore[foreignPodHost]++
else podsScore[foreignPodHost] = 1
})
2017-01-17 21:17:07 +01:00
return callback()
})
}
function computeWinningPods (hosts, 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 = hosts.length / 2
2017-01-17 21:17:07 +01:00
Object.keys(podsScore).forEach(function (podHost) {
// If the pod is not me and with a good score we add it
if (isMe(podHost) === false && podsScore[podHost] > baseScore) {
podsList.push({ host: podHost })
}
})
return podsList
}
function getForeignPodsList (host, 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(constants.REMOTE_SCHEME.HTTP + '://' + host + 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
2016-12-11 21:50:51 +01:00
db.Request.deactivate()
// Flush pool requests
2016-12-11 21:50:51 +01:00
db.Request.forceSend()
2016-07-18 17:17:52 +02:00
eachLimit(podsList, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
const params = {
url: constants.REMOTE_SCHEME.HTTP + '://' + pod.host + '/api/' + constants.API_VERSION + '/pods/',
method: 'POST',
json: {
host: constants.CONFIG.WEBSERVER.HOST,
publicKey: cert
}
}
requests.makeRetryRequest(params, function (err, res, body) {
if (err) {
logger.error('Error with adding %s pod.', pod.host, { error: err })
// Don't break the process
return callbackEach()
}
if (res.statusCode === 200) {
2016-12-11 21:50:51 +01:00
const podObj = db.Pod.build({ host: pod.host, publicKey: body.cert })
podObj.save().asCallback(function (err, podCreated) {
if (err) {
logger.error('Cannot add friend %s pod.', pod.host, { error: err })
return callbackEach()
}
// Add our videos to the request scheduler
2016-12-24 16:59:17 +01:00
sendOwnedVideosToPod(podCreated.id)
return callbackEach()
})
} else {
logger.error('Status not 200 for %s pod.', pod.host)
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
2016-12-11 21:50:51 +01:00
db.Request.activate()
logger.debug('makeRequestsToWinningPods finished.')
return callback()
})
}
2017-01-04 20:59:23 +01:00
// Wrapper that populate "toIds" argument with all our friends if it is not specified
// { type, endpoint, data, toIds, transaction }
function createRequest (options, callback) {
if (!callback) callback = function () {}
if (options.toIds) return _createRequest(options, callback)
2016-12-11 21:50:51 +01:00
2017-01-04 20:59:23 +01:00
// If the "toIds" pods is not specified, we send the request to all our friends
db.Pod.listAllIds(options.transaction, function (err, podIds) {
2016-12-11 21:50:51 +01:00
if (err) {
logger.error('Cannot get pod ids', { error: err })
return
}
const newOptions = Object.assign(options, { toIds: podIds })
return _createRequest(newOptions, callback)
2016-12-11 21:50:51 +01:00
})
}
// { type, endpoint, data, toIds, transaction }
function _createRequest (options, callback) {
const type = options.type
const endpoint = options.endpoint
const data = options.data
const toIds = options.toIds
const transaction = options.transaction
2016-12-11 21:50:51 +01:00
const pods = []
// If there are no destination pods abort
if (toIds.length === 0) return callback(null)
2016-12-11 21:50:51 +01:00
2017-01-04 20:59:23 +01:00
toIds.forEach(function (toPod) {
2016-12-11 21:50:51 +01:00
pods.push(db.Pod.build({ id: toPod }))
})
const createQuery = {
2016-11-01 18:47:57 +01:00
endpoint,
request: {
type: type,
data: data
}
}
const dbRequestOptions = {
transaction
}
2016-12-11 21:50:51 +01:00
return db.Request.create(createQuery, dbRequestOptions).asCallback(function (err, request) {
if (err) return callback(err)
return request.setPods(pods, dbRequestOptions).asCallback(callback)
})
}
function isMe (host) {
return host === constants.CONFIG.WEBSERVER.HOST
}