2017-05-15 20:22:03 +00:00
|
|
|
import { each, eachLimit, eachSeries, series, waterfall } from 'async'
|
|
|
|
import request = require('request')
|
2016-02-07 10:23:23 +00:00
|
|
|
|
2017-05-22 18:58:25 +00:00
|
|
|
import { database as db } from '../initializers/database'
|
2017-05-15 20:22:03 +00:00
|
|
|
import {
|
|
|
|
API_VERSION,
|
|
|
|
CONFIG,
|
|
|
|
REQUESTS_IN_PARALLEL,
|
|
|
|
REQUEST_ENDPOINTS,
|
|
|
|
REQUEST_ENDPOINT_ACTIONS,
|
|
|
|
REMOTE_SCHEME
|
|
|
|
} from '../initializers'
|
|
|
|
import {
|
|
|
|
logger,
|
|
|
|
getMyPublicCert,
|
|
|
|
makeSecureRequest,
|
|
|
|
makeRetryRequest,
|
|
|
|
createEmptyCallback
|
|
|
|
} from '../helpers'
|
|
|
|
import {
|
|
|
|
RequestScheduler,
|
|
|
|
RequestVideoQaduScheduler,
|
|
|
|
RequestVideoEventScheduler
|
|
|
|
} from './request'
|
|
|
|
|
|
|
|
const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
|
2017-02-21 20:35:59 +00:00
|
|
|
|
2017-02-18 17:37:26 +00:00
|
|
|
const requestScheduler = new RequestScheduler()
|
2017-02-27 20:56:55 +00:00
|
|
|
const requestVideoQaduScheduler = new RequestVideoQaduScheduler()
|
|
|
|
const requestVideoEventScheduler = new RequestVideoEventScheduler()
|
2017-01-17 19:59:16 +00:00
|
|
|
|
2017-05-15 20:22:03 +00:00
|
|
|
function activateSchedulers () {
|
2017-02-18 09:29:36 +00:00
|
|
|
requestScheduler.activate()
|
2017-02-27 20:56:55 +00:00
|
|
|
requestVideoQaduScheduler.activate()
|
|
|
|
requestVideoEventScheduler.activate()
|
2017-02-18 09:29:36 +00:00
|
|
|
}
|
|
|
|
|
2017-01-06 22:24:47 +00:00
|
|
|
function addVideoToFriends (videoData, transaction, callback) {
|
|
|
|
const options = {
|
2017-01-17 19:59:16 +00:00
|
|
|
type: ENDPOINT_ACTIONS.ADD,
|
2017-05-15 20:22:03 +00:00
|
|
|
endpoint: REQUEST_ENDPOINTS.VIDEOS,
|
2017-01-06 22:24:47 +00:00
|
|
|
data: videoData,
|
|
|
|
transaction
|
|
|
|
}
|
|
|
|
createRequest(options, callback)
|
2016-02-07 10:23:23 +00:00
|
|
|
}
|
|
|
|
|
2017-01-06 22:24:47 +00:00
|
|
|
function updateVideoToFriends (videoData, transaction, callback) {
|
|
|
|
const options = {
|
2017-01-17 19:59:16 +00:00
|
|
|
type: ENDPOINT_ACTIONS.UPDATE,
|
2017-05-15 20:22:03 +00:00
|
|
|
endpoint: REQUEST_ENDPOINTS.VIDEOS,
|
2017-01-06 22:24:47 +00:00
|
|
|
data: videoData,
|
|
|
|
transaction
|
|
|
|
}
|
|
|
|
createRequest(options, callback)
|
2017-01-04 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function removeVideoToFriends (videoParams) {
|
2017-01-06 22:24:47 +00:00
|
|
|
const options = {
|
2017-01-17 19:59:16 +00:00
|
|
|
type: ENDPOINT_ACTIONS.REMOVE,
|
2017-05-15 20:22:03 +00:00
|
|
|
endpoint: REQUEST_ENDPOINTS.VIDEOS,
|
2017-01-06 22:24:47 +00:00
|
|
|
data: videoParams
|
|
|
|
}
|
|
|
|
createRequest(options)
|
2017-01-04 19:59:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function reportAbuseVideoToFriend (reportData, video) {
|
2017-01-10 21:24:42 +00:00
|
|
|
const options = {
|
2017-01-17 19:59:16 +00:00
|
|
|
type: ENDPOINT_ACTIONS.REPORT_ABUSE,
|
2017-05-15 20:22:03 +00:00
|
|
|
endpoint: REQUEST_ENDPOINTS.VIDEOS,
|
2017-01-10 21:24:42 +00:00
|
|
|
data: reportData,
|
|
|
|
toIds: [ video.Author.podId ]
|
|
|
|
}
|
|
|
|
createRequest(options)
|
2016-12-29 18:07:05 +00:00
|
|
|
}
|
|
|
|
|
2017-05-15 20:22:03 +00:00
|
|
|
function quickAndDirtyUpdateVideoToFriends (qaduParams, transaction?, callback?) {
|
2017-02-21 20:35:59 +00:00
|
|
|
const options = {
|
2017-03-08 20:35:43 +00:00
|
|
|
videoId: qaduParams.videoId,
|
|
|
|
type: qaduParams.type,
|
2017-02-21 20:35:59 +00:00
|
|
|
transaction
|
|
|
|
}
|
|
|
|
return createVideoQaduRequest(options, callback)
|
|
|
|
}
|
|
|
|
|
2017-03-08 20:35:43 +00:00
|
|
|
function quickAndDirtyUpdatesVideoToFriends (qadusParams, transaction, finalCallback) {
|
|
|
|
const tasks = []
|
|
|
|
|
|
|
|
qadusParams.forEach(function (qaduParams) {
|
|
|
|
const fun = function (callback) {
|
|
|
|
quickAndDirtyUpdateVideoToFriends(qaduParams, transaction, callback)
|
|
|
|
}
|
|
|
|
|
|
|
|
tasks.push(fun)
|
|
|
|
})
|
|
|
|
|
|
|
|
series(tasks, finalCallback)
|
|
|
|
}
|
|
|
|
|
2017-05-15 20:22:03 +00:00
|
|
|
function addEventToRemoteVideo (eventParams, transaction?, callback?) {
|
2017-02-26 17:57:33 +00:00
|
|
|
const options = {
|
2017-03-08 20:35:43 +00:00
|
|
|
videoId: eventParams.videoId,
|
|
|
|
type: eventParams.type,
|
2017-02-26 17:57:33 +00:00
|
|
|
transaction
|
|
|
|
}
|
|
|
|
createVideoEventRequest(options, callback)
|
|
|
|
}
|
|
|
|
|
2017-03-08 20:35:43 +00:00
|
|
|
function addEventsToRemoteVideo (eventsParams, transaction, finalCallback) {
|
|
|
|
const tasks = []
|
|
|
|
|
|
|
|
eventsParams.forEach(function (eventParams) {
|
|
|
|
const fun = function (callback) {
|
|
|
|
addEventToRemoteVideo(eventParams, transaction, callback)
|
|
|
|
}
|
|
|
|
|
|
|
|
tasks.push(fun)
|
|
|
|
})
|
|
|
|
|
|
|
|
series(tasks, finalCallback)
|
|
|
|
}
|
|
|
|
|
2016-02-07 10:23:23 +00:00
|
|
|
function hasFriends (callback) {
|
2016-12-11 20:50:51 +00:00
|
|
|
db.Pod.countAll(function (err, count) {
|
2016-02-07 10:23:23 +00:00
|
|
|
if (err) return callback(err)
|
|
|
|
|
2016-05-11 19:19:34 +00:00
|
|
|
const hasFriends = (count !== 0)
|
|
|
|
callback(null, hasFriends)
|
2016-02-07 10:23:23 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
function makeFriends (hosts, callback) {
|
2016-05-11 19:19:34 +00:00
|
|
|
const podsScore = {}
|
2016-02-07 10:23:23 +00:00
|
|
|
|
|
|
|
logger.info('Make friends!')
|
2017-05-15 20:22:03 +00:00
|
|
|
getMyPublicCert(function (err, cert) {
|
2016-02-07 10:23:23 +00:00
|
|
|
if (err) {
|
|
|
|
logger.error('Cannot read public cert.')
|
|
|
|
return callback(err)
|
|
|
|
}
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
eachSeries(hosts, function (host, callbackEach) {
|
|
|
|
computeForeignPodsList(host, podsScore, callbackEach)
|
2016-02-29 17:52:12 +00:00
|
|
|
}, function (err) {
|
2016-02-04 20:10:33 +00:00
|
|
|
if (err) return callback(err)
|
|
|
|
|
2016-05-11 19:19:34 +00:00
|
|
|
logger.debug('Pods scores computed.', { podsScore: podsScore })
|
2016-11-14 19:03:04 +00:00
|
|
|
const podsList = computeWinningPods(hosts, podsScore)
|
2016-05-11 19:19:34 +00:00
|
|
|
logger.debug('Pods that we keep.', { podsToKeep: podsList })
|
2016-02-07 10:23:23 +00:00
|
|
|
|
2016-05-11 19:19:34 +00:00
|
|
|
makeRequestsToWinningPods(cert, podsList, callback)
|
2016-02-04 20:10:33 +00:00
|
|
|
})
|
2016-02-07 10:23:23 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
function quitFriends (callback) {
|
|
|
|
// Stop pool requests
|
2017-02-18 09:29:36 +00:00
|
|
|
requestScheduler.deactivate()
|
2016-02-07 10:23:23 +00:00
|
|
|
|
2016-07-18 15:17:52 +00:00
|
|
|
waterfall([
|
2016-12-24 15:59:17 +00:00
|
|
|
function flushRequests (callbackAsync) {
|
2017-02-21 20:35:59 +00:00
|
|
|
requestScheduler.flush(err => callbackAsync(err))
|
|
|
|
},
|
|
|
|
|
|
|
|
function flushVideoQaduRequests (callbackAsync) {
|
2017-02-27 20:56:55 +00:00
|
|
|
requestVideoQaduScheduler.flush(err => callbackAsync(err))
|
2016-12-24 15:59:17 +00:00
|
|
|
},
|
|
|
|
|
2016-05-15 08:42:17 +00:00
|
|
|
function getPodsList (callbackAsync) {
|
2016-12-11 20:50:51 +00:00
|
|
|
return db.Pod.list(callbackAsync)
|
2016-05-15 08:42:17 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
function announceIQuitMyFriends (pods, callbackAsync) {
|
2016-06-18 14:13:54 +00:00
|
|
|
const requestParams = {
|
2016-05-15 08:42:17 +00:00
|
|
|
method: 'POST',
|
2017-05-15 20:22:03 +00:00
|
|
|
path: '/api/' + API_VERSION + '/remote/pods/remove',
|
|
|
|
sign: true,
|
|
|
|
toPod: null
|
2016-02-04 20:10:33 +00:00
|
|
|
}
|
|
|
|
|
2016-05-15 08:42:17 +00:00
|
|
|
// Announce we quit them
|
2016-06-18 14:13:54 +00:00
|
|
|
// We don't care if the request fails
|
|
|
|
// The other pod will exclude us automatically after a while
|
2017-05-15 20:22:03 +00:00
|
|
|
eachLimit(pods, REQUESTS_IN_PARALLEL, function (pod, callbackEach) {
|
2016-06-18 14:13:54 +00:00
|
|
|
requestParams.toPod = pod
|
2017-05-15 20:22:03 +00:00
|
|
|
makeSecureRequest(requestParams, callbackEach)
|
2016-06-18 14:13:54 +00:00
|
|
|
}, function (err) {
|
|
|
|
if (err) {
|
|
|
|
logger.error('Some errors while quitting friends.', { err: err })
|
|
|
|
// Don't stop the process
|
|
|
|
}
|
|
|
|
|
2016-10-21 09:20:45 +00:00
|
|
|
return callbackAsync(null, pods)
|
2016-05-15 08:42:17 +00:00
|
|
|
})
|
|
|
|
},
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2016-10-21 09:20:45 +00:00
|
|
|
function removePodsFromDB (pods, callbackAsync) {
|
2017-05-15 20:22:03 +00:00
|
|
|
each(pods, function (pod: any, callbackEach) {
|
2016-12-11 20:50:51 +00:00
|
|
|
pod.destroy().asCallback(callbackEach)
|
2016-06-24 15:42:51 +00:00
|
|
|
}, callbackAsync)
|
2016-05-15 08:42:17 +00:00
|
|
|
}
|
|
|
|
], function (err) {
|
|
|
|
// Don't forget to re activate the scheduler, even if there was an error
|
2017-02-18 09:29:36 +00:00
|
|
|
requestScheduler.activate()
|
2016-05-15 08:42:17 +00:00
|
|
|
|
|
|
|
if (err) return callback(err)
|
|
|
|
|
|
|
|
logger.info('Removed all remote videos.')
|
|
|
|
return callback(null)
|
2016-02-07 10:23:23 +00:00
|
|
|
})
|
|
|
|
}
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2016-06-18 14:13:54 +00:00
|
|
|
function sendOwnedVideosToPod (podId) {
|
2016-12-24 15:59:17 +00:00
|
|
|
db.Video.listOwnedAndPopulateAuthorAndTags(function (err, videosList) {
|
2016-06-18 14:13:54 +00:00
|
|
|
if (err) {
|
|
|
|
logger.error('Cannot get the list of videos we own.')
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
videosList.forEach(function (video) {
|
2016-12-29 18:07:05 +00:00
|
|
|
video.toAddRemoteJSON(function (err, remoteVideo) {
|
2016-06-18 14:13:54 +00:00
|
|
|
if (err) {
|
|
|
|
logger.error('Cannot convert video to remote.', { error: err })
|
|
|
|
// Don't break the process
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-01-10 21:24:42 +00:00
|
|
|
const options = {
|
|
|
|
type: 'add',
|
2017-05-15 20:22:03 +00:00
|
|
|
endpoint: REQUEST_ENDPOINTS.VIDEOS,
|
2017-01-10 21:24:42 +00:00
|
|
|
data: remoteVideo,
|
|
|
|
toIds: [ podId ]
|
|
|
|
}
|
|
|
|
createRequest(options)
|
2016-06-18 14:13:54 +00:00
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
2016-02-07 10:23:23 +00:00
|
|
|
}
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2017-02-27 20:56:55 +00:00
|
|
|
function getRequestScheduler () {
|
|
|
|
return requestScheduler
|
|
|
|
}
|
|
|
|
|
|
|
|
function getRequestVideoQaduScheduler () {
|
|
|
|
return requestVideoQaduScheduler
|
|
|
|
}
|
|
|
|
|
|
|
|
function getRequestVideoEventScheduler () {
|
|
|
|
return requestVideoEventScheduler
|
|
|
|
}
|
|
|
|
|
2016-02-07 10:23:23 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2017-05-15 20:22:03 +00:00
|
|
|
export {
|
|
|
|
activateSchedulers,
|
|
|
|
addVideoToFriends,
|
|
|
|
updateVideoToFriends,
|
|
|
|
reportAbuseVideoToFriend,
|
|
|
|
quickAndDirtyUpdateVideoToFriends,
|
|
|
|
quickAndDirtyUpdatesVideoToFriends,
|
|
|
|
addEventToRemoteVideo,
|
|
|
|
addEventsToRemoteVideo,
|
|
|
|
hasFriends,
|
|
|
|
makeFriends,
|
|
|
|
quitFriends,
|
|
|
|
removeVideoToFriends,
|
|
|
|
sendOwnedVideosToPod,
|
|
|
|
getRequestScheduler,
|
|
|
|
getRequestVideoQaduScheduler,
|
|
|
|
getRequestVideoEventScheduler
|
|
|
|
}
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2016-02-07 10:23:23 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
function computeForeignPodsList (host, podsScore, callback) {
|
2017-01-04 19:59:23 +00:00
|
|
|
getForeignPodsList(host, function (err, res) {
|
2016-02-29 17:52:12 +00:00
|
|
|
if (err) return callback(err)
|
2016-06-18 14:13:54 +00:00
|
|
|
|
2017-01-04 19:59:23 +00:00
|
|
|
const foreignPodsList = res.data
|
2016-06-18 14:13:54 +00:00
|
|
|
|
|
|
|
// Let's give 1 point to the pod we ask the friends list
|
2016-11-14 19:03:04 +00:00
|
|
|
foreignPodsList.push({ host })
|
2016-02-29 17:52:12 +00:00
|
|
|
|
2016-05-11 19:19:34 +00:00
|
|
|
foreignPodsList.forEach(function (foreignPod) {
|
2016-11-14 19:03:04 +00:00
|
|
|
const foreignPodHost = foreignPod.host
|
2016-02-29 17:52:12 +00:00
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
if (podsScore[foreignPodHost]) podsScore[foreignPodHost]++
|
|
|
|
else podsScore[foreignPodHost] = 1
|
2016-02-29 17:52:12 +00:00
|
|
|
})
|
2016-05-10 19:19:24 +00:00
|
|
|
|
2017-01-17 20:17:07 +00:00
|
|
|
return callback()
|
2016-02-29 17:52:12 +00:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
function computeWinningPods (hosts, podsScore) {
|
2016-02-29 17:52:12 +00:00
|
|
|
// Build the list of pods to add
|
|
|
|
// Only add a pod if it exists in more than a half base pods
|
2016-05-11 19:19:34 +00:00
|
|
|
const podsList = []
|
2016-11-14 19:03:04 +00:00
|
|
|
const baseScore = hosts.length / 2
|
2017-01-17 20:17:07 +00:00
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
Object.keys(podsScore).forEach(function (podHost) {
|
2016-10-23 17:31:47 +00:00
|
|
|
// If the pod is not me and with a good score we add it
|
2016-11-14 19:03:04 +00:00
|
|
|
if (isMe(podHost) === false && podsScore[podHost] > baseScore) {
|
|
|
|
podsList.push({ host: podHost })
|
2016-10-23 17:31:47 +00:00
|
|
|
}
|
2016-02-29 17:52:12 +00:00
|
|
|
})
|
2016-05-15 08:42:17 +00:00
|
|
|
|
2016-05-11 19:19:34 +00:00
|
|
|
return podsList
|
2016-02-29 17:52:12 +00:00
|
|
|
}
|
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
function getForeignPodsList (host, callback) {
|
2017-05-15 20:22:03 +00:00
|
|
|
const path = '/api/' + API_VERSION + '/pods'
|
2016-02-04 20:10:33 +00:00
|
|
|
|
2017-05-15 20:22:03 +00:00
|
|
|
request.get(REMOTE_SCHEME.HTTP + '://' + host + path, function (err, response, body) {
|
2016-02-07 10:23:23 +00:00
|
|
|
if (err) return callback(err)
|
2016-02-05 18:02:05 +00:00
|
|
|
|
2016-08-23 12:37:36 +00:00
|
|
|
try {
|
|
|
|
const json = JSON.parse(body)
|
|
|
|
return callback(null, json)
|
|
|
|
} catch (err) {
|
|
|
|
return callback(err)
|
|
|
|
}
|
2016-02-07 10:23:23 +00:00
|
|
|
})
|
|
|
|
}
|
2016-02-29 17:52:12 +00:00
|
|
|
|
2016-05-11 19:19:34 +00:00
|
|
|
function makeRequestsToWinningPods (cert, podsList, callback) {
|
2016-02-29 17:52:12 +00:00
|
|
|
// Stop pool requests
|
2017-02-18 09:29:36 +00:00
|
|
|
requestScheduler.deactivate()
|
2016-02-29 17:52:12 +00:00
|
|
|
// Flush pool requests
|
2017-02-18 09:29:36 +00:00
|
|
|
requestScheduler.forceSend()
|
2016-02-29 17:52:12 +00:00
|
|
|
|
2017-05-22 18:58:25 +00:00
|
|
|
eachLimit(podsList, REQUESTS_IN_PARALLEL, function (pod: { host: string }, callbackEach) {
|
2016-06-18 14:13:54 +00:00
|
|
|
const params = {
|
2017-05-15 20:22:03 +00:00
|
|
|
url: REMOTE_SCHEME.HTTP + '://' + pod.host + '/api/' + API_VERSION + '/pods/',
|
2016-06-18 14:13:54 +00:00
|
|
|
method: 'POST',
|
|
|
|
json: {
|
2017-05-15 20:22:03 +00:00
|
|
|
host: CONFIG.WEBSERVER.HOST,
|
|
|
|
email: CONFIG.ADMIN.EMAIL,
|
2016-06-18 14:13:54 +00:00
|
|
|
publicKey: cert
|
|
|
|
}
|
2016-02-29 17:52:12 +00:00
|
|
|
}
|
|
|
|
|
2017-05-22 18:58:25 +00:00
|
|
|
makeRetryRequest(params, function (err, res, body: { cert: string, email: string }) {
|
2016-06-18 14:13:54 +00:00
|
|
|
if (err) {
|
2016-11-14 19:03:04 +00:00
|
|
|
logger.error('Error with adding %s pod.', pod.host, { error: err })
|
2016-06-18 14:13:54 +00:00
|
|
|
// Don't break the process
|
|
|
|
return callbackEach()
|
|
|
|
}
|
2016-02-29 17:52:12 +00:00
|
|
|
|
2016-06-18 14:13:54 +00:00
|
|
|
if (res.statusCode === 200) {
|
2017-02-16 18:19:56 +00:00
|
|
|
const podObj = db.Pod.build({ host: pod.host, publicKey: body.cert, email: body.email })
|
2016-12-11 20:50:51 +00:00
|
|
|
podObj.save().asCallback(function (err, podCreated) {
|
2016-06-30 20:39:08 +00:00
|
|
|
if (err) {
|
2016-11-14 19:03:04 +00:00
|
|
|
logger.error('Cannot add friend %s pod.', pod.host, { error: err })
|
2016-06-30 20:39:08 +00:00
|
|
|
return callbackEach()
|
|
|
|
}
|
2016-02-29 17:52:12 +00:00
|
|
|
|
2016-06-18 14:13:54 +00:00
|
|
|
// Add our videos to the request scheduler
|
2016-12-24 15:59:17 +00:00
|
|
|
sendOwnedVideosToPod(podCreated.id)
|
2016-02-29 17:52:12 +00:00
|
|
|
|
2016-06-18 14:13:54 +00:00
|
|
|
return callbackEach()
|
|
|
|
})
|
|
|
|
} else {
|
2016-11-14 19:03:04 +00:00
|
|
|
logger.error('Status not 200 for %s pod.', pod.host)
|
2016-06-18 14:13:54 +00:00
|
|
|
return callbackEach()
|
2016-02-29 17:52:12 +00:00
|
|
|
}
|
2016-06-18 14:13:54 +00:00
|
|
|
})
|
|
|
|
}, function endRequests () {
|
|
|
|
// Final callback, we've ended all the requests
|
|
|
|
// Now we made new friends, we can re activate the pool of requests
|
2017-02-18 09:29:36 +00:00
|
|
|
requestScheduler.activate()
|
2016-06-18 14:13:54 +00:00
|
|
|
|
|
|
|
logger.debug('makeRequestsToWinningPods finished.')
|
|
|
|
return callback()
|
2016-02-29 17:52:12 +00:00
|
|
|
})
|
|
|
|
}
|
2016-06-28 18:10:32 +00:00
|
|
|
|
2017-01-04 19:59:23 +00:00
|
|
|
// Wrapper that populate "toIds" argument with all our friends if it is not specified
|
2017-01-06 22:24:47 +00:00
|
|
|
// { type, endpoint, data, toIds, transaction }
|
2017-05-15 20:22:03 +00:00
|
|
|
function createRequest (options, callback?) {
|
|
|
|
if (!callback) callback = function () { /* empty */ }
|
2017-02-18 09:29:36 +00:00
|
|
|
if (options.toIds) return requestScheduler.createRequest(options, callback)
|
2016-12-11 20:50:51 +00:00
|
|
|
|
2017-01-04 19:59:23 +00:00
|
|
|
// If the "toIds" pods is not specified, we send the request to all our friends
|
2017-01-06 22:24:47 +00:00
|
|
|
db.Pod.listAllIds(options.transaction, function (err, podIds) {
|
2016-12-11 20:50:51 +00:00
|
|
|
if (err) {
|
|
|
|
logger.error('Cannot get pod ids', { error: err })
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-01-06 22:24:47 +00:00
|
|
|
const newOptions = Object.assign(options, { toIds: podIds })
|
2017-02-18 09:29:36 +00:00
|
|
|
return requestScheduler.createRequest(newOptions, callback)
|
2016-06-28 18:10:32 +00:00
|
|
|
})
|
|
|
|
}
|
2016-10-23 17:31:47 +00:00
|
|
|
|
2017-02-21 20:35:59 +00:00
|
|
|
function createVideoQaduRequest (options, callback) {
|
2017-05-15 20:22:03 +00:00
|
|
|
if (!callback) callback = createEmptyCallback()
|
2017-02-21 20:35:59 +00:00
|
|
|
|
2017-02-27 20:56:55 +00:00
|
|
|
requestVideoQaduScheduler.createRequest(options, callback)
|
2017-02-21 20:35:59 +00:00
|
|
|
}
|
|
|
|
|
2017-02-26 17:57:33 +00:00
|
|
|
function createVideoEventRequest (options, callback) {
|
2017-05-15 20:22:03 +00:00
|
|
|
if (!callback) callback = createEmptyCallback()
|
2017-02-26 17:57:33 +00:00
|
|
|
|
2017-02-27 20:56:55 +00:00
|
|
|
requestVideoEventScheduler.createRequest(options, callback)
|
2017-02-26 17:57:33 +00:00
|
|
|
}
|
|
|
|
|
2016-11-14 19:03:04 +00:00
|
|
|
function isMe (host) {
|
2017-05-15 20:22:03 +00:00
|
|
|
return host === CONFIG.WEBSERVER.HOST
|
2016-10-23 17:31:47 +00:00
|
|
|
}
|