const eachLimit = require('async/eachLimit')
const eachSeries = require('async/eachSeries')
const fs = require('fs')
-const mongoose = require('mongoose')
const request = require('request')
const waterfall = require('async/waterfall')
const constants = require('../initializers/constants')
+const db = require('../initializers/database')
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')
-
const friends = {
- addVideoToFriends: addVideoToFriends,
- hasFriends: hasFriends,
- getMyCertificate: getMyCertificate,
- makeFriends: makeFriends,
- quitFriends: quitFriends,
- removeVideoToFriends: removeVideoToFriends,
- sendOwnedVideosToPod: sendOwnedVideosToPod
+ addVideoToFriends,
+ updateVideoToFriends,
+ reportAbuseVideoToFriend,
+ hasFriends,
+ getMyCertificate,
+ makeFriends,
+ quitFriends,
+ removeVideoToFriends,
+ sendOwnedVideosToPod
+}
+
+function addVideoToFriends (videoData) {
+ createRequest('add', constants.REQUEST_ENDPOINTS.VIDEOS, videoData)
+}
+
+function updateVideoToFriends (videoData) {
+ createRequest('update', constants.REQUEST_ENDPOINTS.VIDEOS, videoData)
}
-function addVideoToFriends (video) {
- createRequest('add', video)
+function removeVideoToFriends (videoParams) {
+ createRequest('remove', constants.REQUEST_ENDPOINTS.VIDEOS, videoParams)
+}
+
+function reportAbuseVideoToFriend (reportData, video) {
+ createRequest('report-abuse', constants.REQUEST_ENDPOINTS.VIDEOS, reportData, [ video.Author.podId ])
}
function hasFriends (callback) {
- Pod.countAll(function (err, count) {
+ db.Pod.countAll(function (err, count) {
if (err) return callback(err)
const hasFriends = (count !== 0)
fs.readFile(constants.CONFIG.STORAGE.CERT_DIR + 'peertube.pub', 'utf8', callback)
}
-function makeFriends (urls, callback) {
+function makeFriends (hosts, callback) {
const podsScore = {}
logger.info('Make friends!')
return callback(err)
}
- eachSeries(urls, function (url, callbackEach) {
- computeForeignPodsList(url, podsScore, callbackEach)
+ eachSeries(hosts, function (host, callbackEach) {
+ computeForeignPodsList(host, podsScore, callbackEach)
}, function (err) {
if (err) return callback(err)
logger.debug('Pods scores computed.', { podsScore: podsScore })
- const podsList = computeWinningPods(urls, podsScore)
+ const podsList = computeWinningPods(hosts, podsScore)
logger.debug('Pods that we keep.', { podsToKeep: podsList })
makeRequestsToWinningPods(cert, podsList, callback)
function quitFriends (callback) {
// Stop pool requests
- Request.deactivate()
- // Flush pool requests
- Request.flush()
+ db.Request.deactivate()
waterfall([
+ function flushRequests (callbackAsync) {
+ db.Request.flush(callbackAsync)
+ },
+
function getPodsList (callbackAsync) {
- return Pod.list(callbackAsync)
+ return db.Pod.list(callbackAsync)
},
function announceIQuitMyFriends (pods, callbackAsync) {
// Don't stop the process
}
- return callbackAsync()
+ return callbackAsync(null, pods)
})
},
- function removePodsFromDB (callbackAsync) {
- Pod.removeAll(function (err) {
- return callbackAsync(err)
- })
- },
-
- function listRemoteVideos (callbackAsync) {
- logger.info('Broke friends, so sad :(')
-
- Video.listRemotes(callbackAsync)
- },
-
- function removeTheRemoteVideos (videosList, callbackAsync) {
- each(videosList, function (video, callbackEach) {
- video.remove(callbackEach)
+ function removePodsFromDB (pods, callbackAsync) {
+ each(pods, function (pod, callbackEach) {
+ pod.destroy().asCallback(callbackEach)
}, callbackAsync)
}
], function (err) {
// Don't forget to re activate the scheduler, even if there was an error
- Request.activate()
+ db.Request.activate()
if (err) return callback(err)
})
}
-function removeVideoToFriends (videoParams) {
- createRequest('remove', videoParams)
-}
-
function sendOwnedVideosToPod (podId) {
- Video.listOwned(function (err, videosList) {
+ db.Video.listOwnedAndPopulateAuthorAndTags(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) {
+ video.toAddRemoteJSON(function (err, remoteVideo) {
if (err) {
logger.error('Cannot convert video to remote.', { error: err })
// Don't break the process
return
}
- createRequest('add', remoteVideo, [ podId ])
+ createRequest('add', constants.REQUEST_ENDPOINTS.VIDEOS, remoteVideo, [ podId ])
})
})
})
// ---------------------------------------------------------------------------
-function computeForeignPodsList (url, podsScore, callback) {
- getForeignPodsList(url, function (err, foreignPodsList) {
+function computeForeignPodsList (host, podsScore, callback) {
+ getForeignPodsList(host, function (err, res) {
if (err) return callback(err)
- if (!foreignPodsList) foreignPodsList = []
+ const foreignPodsList = res.data
// Let's give 1 point to the pod we ask the friends list
- foreignPodsList.push({ url: url })
+ foreignPodsList.push({ host })
foreignPodsList.forEach(function (foreignPod) {
- const foreignPodUrl = foreignPod.url
+ const foreignPodHost = foreignPod.host
- if (podsScore[foreignPodUrl]) podsScore[foreignPodUrl]++
- else podsScore[foreignPodUrl] = 1
+ if (podsScore[foreignPodHost]) podsScore[foreignPodHost]++
+ else podsScore[foreignPodHost] = 1
})
callback()
})
}
-function computeWinningPods (urls, podsScore) {
+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 = urls.length / 2
- Object.keys(podsScore).forEach(function (pod) {
- if (podsScore[pod] > baseScore) podsList.push({ url: pod })
+ const baseScore = hosts.length / 2
+ 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 (url, callback) {
+function getForeignPodsList (host, callback) {
const path = '/api/' + constants.API_VERSION + '/pods'
- request.get(url + path, function (err, response, body) {
+ request.get(constants.REMOTE_SCHEME.HTTP + '://' + host + path, function (err, response, body) {
if (err) return callback(err)
try {
function makeRequestsToWinningPods (cert, podsList, callback) {
// Stop pool requests
- Request.deactivate()
+ db.Request.deactivate()
// Flush pool requests
- Request.forceSend()
+ db.Request.forceSend()
eachLimit(podsList, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
const params = {
- url: pod.url + '/api/' + constants.API_VERSION + '/pods/',
+ url: constants.REMOTE_SCHEME.HTTP + '://' + pod.host + '/api/' + constants.API_VERSION + '/pods/',
method: 'POST',
json: {
- url: constants.CONFIG.WEBSERVER.URL,
+ host: constants.CONFIG.WEBSERVER.HOST,
publicKey: cert
}
}
requests.makeRetryRequest(params, function (err, res, body) {
if (err) {
- logger.error('Error with adding %s pod.', pod.url, { error: err })
+ logger.error('Error with adding %s pod.', pod.host, { 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) {
+ 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.url, { error: err })
+ logger.error('Cannot add friend %s pod.', pod.host, { error: err })
return callbackEach()
}
// Add our videos to the request scheduler
- sendOwnedVideosToPod(podCreated._id)
+ sendOwnedVideosToPod(podCreated.id)
return callbackEach()
})
} else {
- logger.error('Status not 200 for %s pod.', pod.url)
+ 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
- Request.activate()
+ db.Request.activate()
logger.debug('makeRequestsToWinningPods finished.')
return callback()
})
}
-function createRequest (type, data, to) {
- const req = new Request({
+// Wrapper that populate "toIds" argument with all our friends if it is not specified
+function createRequest (type, endpoint, data, toIds) {
+ if (toIds) return _createRequest(type, endpoint, data, toIds)
+
+ // If the "toIds" pods is not specified, we send the request to all our friends
+ db.Pod.listAllIds(function (err, podIds) {
+ if (err) {
+ logger.error('Cannot get pod ids', { error: err })
+ return
+ }
+
+ return _createRequest(type, endpoint, data, podIds)
+ })
+}
+
+function _createRequest (type, endpoint, data, toIds) {
+ const pods = []
+
+ // If there are no destination pods abort
+ if (toIds.length === 0) return
+
+ toIds.forEach(function (toPod) {
+ pods.push(db.Pod.build({ id: toPod }))
+ })
+
+ const createQuery = {
+ endpoint,
request: {
type: type,
data: data
}
- })
-
- if (to) {
- req.to = to
}
- req.save(function (err) {
- if (err) logger.error('Cannot save the request.', { error: err })
+ // We run in transaction to keep coherency between Request and RequestToPod tables
+ db.sequelize.transaction(function (t) {
+ const dbRequestOptions = {
+ transaction: t
+ }
+
+ return db.Request.create(createQuery, dbRequestOptions).then(function (request) {
+ return request.setPods(pods, dbRequestOptions)
+ })
+ }).asCallback(function (err) {
+ if (err) logger.error('Error in createRequest transaction.', { error: err })
})
}
+
+function isMe (host) {
+ return host === constants.CONFIG.WEBSERVER.HOST
+}
projects / github / Chocobozzz / PeerTube.git / blobdiff