'use strict'
-const async = require('async')
-const config = require('config')
+const each = require('async/each')
+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 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 http = config.get('webserver.https') ? 'https' : 'http'
-const host = config.get('webserver.host')
-const port = config.get('webserver.port')
+const Pod = mongoose.model('Pod')
+const Request = mongoose.model('Request')
const Video = mongoose.model('Video')
-const pods = {
- addVideoToFriends: addVideoToFriends,
- hasFriends: hasFriends,
- getMyCertificate: getMyCertificate,
- makeFriends: makeFriends,
- quitFriends: quitFriends,
- removeVideoToFriends: removeVideoToFriends,
- sendOwnedVideosToPod: sendOwnedVideosToPod
+const friends = {
+ addVideoToFriends,
+ hasFriends,
+ getMyCertificate,
+ makeFriends,
+ quitFriends,
+ removeVideoToFriends,
+ sendOwnedVideosToPod
}
function addVideoToFriends (video) {
- // ensure namePath is null
- video.namePath = null
-
- requestsScheduler.addRequest('add', video)
+ createRequest('add', video)
}
function hasFriends (callback) {
- Pods.count(function (err, count) {
+ Pod.countAll(function (err, count) {
if (err) return callback(err)
const hasFriends = (count !== 0)
}
function getMyCertificate (callback) {
- fs.readFile(peertubeCrypto.getCertDir() + 'peertube.pub', 'utf8', callback)
+ fs.readFile(constants.CONFIG.STORAGE.CERT_DIR + 'peertube.pub', 'utf8', callback)
}
-function makeFriends (callback) {
+function makeFriends (urls, callback) {
const podsScore = {}
logger.info('Make friends!')
return callback(err)
}
- const urls = config.get('network.friends')
-
- async.eachSeries(urls, function (url, callbackEach) {
+ eachSeries(urls, function (url, callbackEach) {
computeForeignPodsList(url, podsScore, callbackEach)
}, function (err) {
if (err) return callback(err)
function quitFriends (callback) {
// Stop pool requests
- requestsScheduler.deactivate()
+ Request.deactivate()
// Flush pool requests
- requestsScheduler.flush()
+ Request.flush()
- async.waterfall([
+ waterfall([
function getPodsList (callbackAsync) {
- return Pods.list(callbackAsync)
+ return Pod.list(callbackAsync)
},
function announceIQuitMyFriends (pods, callbackAsync) {
// 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) {
+ eachLimit(pods, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
requestParams.toPod = pod
requests.makeSecureRequest(requestParams, callbackEach)
}, function (err) {
},
function removePodsFromDB (callbackAsync) {
- Pods.removeAll(function (err) {
+ Pod.removeAll(function (err) {
return callbackAsync(err)
})
},
},
function removeTheRemoteVideos (videosList, callbackAsync) {
- async.each(videosList, function (video, callbackEach) {
+ 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()
+ Request.activate()
if (err) return callback(err)
})
}
-function removeVideoToFriends (video) {
- requestsScheduler.addRequest('remove', video)
+function removeVideoToFriends (videoParams) {
+ createRequest('remove', videoParams)
}
function sendOwnedVideosToPod (podId) {
return
}
- requestsScheduler.addRequestTo([ podId ], 'add', remoteVideo)
+ createRequest('add', remoteVideo, [ podId ])
})
})
})
// ---------------------------------------------------------------------------
-module.exports = pods
+module.exports = friends
// ---------------------------------------------------------------------------
request.get(url + path, function (err, response, body) {
if (err) return callback(err)
- callback(null, JSON.parse(body))
+ try {
+ const json = JSON.parse(body)
+ return callback(null, json)
+ } catch (err) {
+ return callback(err)
+ }
})
}
function makeRequestsToWinningPods (cert, podsList, callback) {
// Stop pool requests
- requestsScheduler.deactivate()
+ Request.deactivate()
// Flush pool requests
- requestsScheduler.forceSend()
+ Request.forceSend()
- async.eachLimit(podsList, constants.REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
+ 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,
+ url: constants.CONFIG.WEBSERVER.URL,
publicKey: cert
}
}
}
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)
+ 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)
}, 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()
+ 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 })
+ })
+}