import * as request from 'request'
import * as Sequelize from 'sequelize'
import * as Promise from 'bluebird'
+import { join } from 'path'
import { database as db } from '../initializers/database'
import {
REQUESTS_IN_PARALLEL,
REQUEST_ENDPOINTS,
REQUEST_ENDPOINT_ACTIONS,
- REMOTE_SCHEME
+ REMOTE_SCHEME,
+ STATIC_PATHS
} from '../initializers'
import {
logger,
import {
RequestEndpoint,
RequestVideoEventType,
- RequestVideoQaduType
+ RequestVideoQaduType,
+ RemoteVideoCreateData,
+ RemoteVideoUpdateData,
+ RemoteVideoRemoveData,
+ RemoteVideoReportAbuseData,
+ ResultList,
+ Pod as FormatedPod
} from '../../shared'
-type QaduParam = { videoId: string, type: RequestVideoQaduType }
-type EventParam = { videoId: string, type: RequestVideoEventType }
+type QaduParam = { videoId: number, type: RequestVideoQaduType }
+type EventParam = { videoId: number, type: RequestVideoEventType }
const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
requestVideoEventScheduler.activate()
}
-function addVideoToFriends (videoData: Object, transaction: Sequelize.Transaction) {
+function addVideoToFriends (videoData: RemoteVideoCreateData, transaction: Sequelize.Transaction) {
const options = {
type: ENDPOINT_ACTIONS.ADD,
endpoint: REQUEST_ENDPOINTS.VIDEOS,
return createRequest(options)
}
-function updateVideoToFriends (videoData: Object, transaction: Sequelize.Transaction) {
+function updateVideoToFriends (videoData: RemoteVideoUpdateData, transaction: Sequelize.Transaction) {
const options = {
type: ENDPOINT_ACTIONS.UPDATE,
endpoint: REQUEST_ENDPOINTS.VIDEOS,
return createRequest(options)
}
-function removeVideoToFriends (videoParams: Object) {
+function removeVideoToFriends (videoParams: RemoteVideoRemoveData) {
const options = {
type: ENDPOINT_ACTIONS.REMOVE,
endpoint: REQUEST_ENDPOINTS.VIDEOS,
return createRequest(options)
}
-function reportAbuseVideoToFriend (reportData: Object, video: VideoInstance, transaction: Sequelize.Transaction) {
+function reportAbuseVideoToFriend (reportData: RemoteVideoReportAbuseData, video: VideoInstance, transaction: Sequelize.Transaction) {
const options = {
type: ENDPOINT_ACTIONS.REPORT_ABUSE,
endpoint: REQUEST_ENDPOINTS.VIDEOS,
function quickAndDirtyUpdatesVideoToFriends (qadusParams: QaduParam[], transaction: Sequelize.Transaction) {
const tasks = []
- qadusParams.forEach(function (qaduParams) {
+ qadusParams.forEach(qaduParams => {
tasks.push(quickAndDirtyUpdateVideoToFriends(qaduParams, transaction))
})
function addEventsToRemoteVideo (eventsParams: EventParam[], transaction: Sequelize.Transaction) {
const tasks = []
- eventsParams.forEach(function (eventParams) {
+ eventsParams.forEach(eventParams => {
tasks.push(addEventToRemoteVideo(eventParams, transaction))
})
logger.info('Make friends!')
return getMyPublicCert()
.then(cert => {
- return Promise.mapSeries(hosts, host => {
- return computeForeignPodsList(host, podsScore)
- }).then(() => cert)
+ return Promise.each(hosts, host => computeForeignPodsList(host, podsScore)).then(() => cert)
})
.then(cert => {
logger.debug('Pods scores computed.', { podsScore: podsScore })
const requestParams = {
method: 'POST' as 'POST',
path: '/api/' + API_VERSION + '/remote/pods/remove',
- sign: true,
toPod: null
}
// The other pod will exclude us automatically after a while
return Promise.map(pods, pod => {
requestParams.toPod = pod
+
return makeSecureRequest(requestParams)
}, { concurrency: REQUESTS_IN_PARALLEL })
.then(() => pods)
.catch(err => {
- logger.error('Some errors while quitting friends.', { err: err })
+ logger.error('Some errors while quitting friends.', err)
// Don't stop the process
})
})
return createRequest(options)
})
.catch(err => {
- logger.error('Cannot convert video to remote.', { error: err })
+ logger.error('Cannot convert video to remote.', err)
// Don't break the process
return undefined
})
})
}
+function fetchRemotePreview (pod: PodInstance, video: VideoInstance) {
+ const host = video.Author.Pod.host
+ const path = join(STATIC_PATHS.PREVIEWS, video.getPreviewName())
+
+ return request.get(REMOTE_SCHEME.HTTP + '://' + host + path)
+}
+
function getRequestScheduler () {
return requestScheduler
}
sendOwnedVideosToPod,
getRequestScheduler,
getRequestVideoQaduScheduler,
- getRequestVideoEventScheduler
+ getRequestVideoEventScheduler,
+ fetchRemotePreview
}
// ---------------------------------------------------------------------------
function computeForeignPodsList (host: string, podsScore: { [ host: string ]: number }) {
// TODO: type res
- return getForeignPodsList(host).then((res: any) => {
- const foreignPodsList = res.data
+ return getForeignPodsList(host).then(res => {
+ const foreignPodsList: { host: string }[] = res.data
// Let's give 1 point to the pod we ask the friends list
foreignPodsList.push({ host })
}
function getForeignPodsList (host: string) {
- return new Promise((res, rej) => {
+ return new Promise< ResultList<FormatedPod> >((res, rej) => {
const path = '/api/' + API_VERSION + '/pods'
- request.get(REMOTE_SCHEME.HTTP + '://' + host + path, function (err, response, body) {
+ request.get(REMOTE_SCHEME.HTTP + '://' + host + path, (err, response, body) => {
if (err) return rej(err)
try {
sendOwnedVideosToPod(podCreated.id)
})
.catch(err => {
- logger.error('Cannot add friend %s pod.', pod.host, { error: err })
+ logger.error('Cannot add friend %s pod.', pod.host, err)
})
} else {
logger.error('Status not 200 for %s pod.', pod.host)