src/pods.js

   1 ;(function () {
   2   'use strict'
   3
   4   var async = require('async')
   5   var config = require('config')
   6   var fs = require('fs')
   7   var request = require('request')
   8
   9   var logger = require('./logger')
  10   var PodsDB = require('./database').PodsDB
  11   var poolRequests = require('./poolRequests')
  12   var utils = require('./utils')
  13
  14   var pods = {}
  15
  16   var http = config.get('webserver.https') ? 'https' : 'http'
  17   var host = config.get('webserver.host')
  18   var port = config.get('webserver.port')
  19
  20   // ----------- Private functions -----------
  21
  22   function getForeignPodsList (url, callback) {
  23     var path = '/api/' + global.API_VERSION + '/pods'
  24
  25     request.get(url + path, function (err, response, body) {
  26       if (err) throw err
  27       callback(JSON.parse(body))
  28     })
  29   }
  30
  31   // ----------- Public functions -----------
  32
  33   pods.list = function (callback) {
  34     PodsDB.find(function (err, pods_list) {
  35       if (err) {
  36         logger.error('Cannot get the list of the pods.', { error: err })
  37         return callback(err)
  38       }
  39
  40       return callback(null, pods_list)
  41     })
  42   }
  43
  44   // { url }
  45   pods.add = function (data, callback) {
  46     logger.info('Adding pod: %s', data.url)
  47
  48     var params = {
  49       url: data.url,
  50       publicKey: data.publicKey,
  51       score: global.FRIEND_BASE_SCORE
  52     }
  53
  54     PodsDB.create(params, function (err, pod) {
  55       if (err) {
  56         logger.error('Cannot insert the pod.', { error: err })
  57         return callback(err)
  58       }
  59
  60       fs.readFile(utils.certDir + 'peertube.pub', 'utf8', function (err, cert) {
  61         if (err) {
  62           logger.error('Cannot read cert file.', { error: err })
  63           return callback(err)
  64         }
  65
  66         return callback(null, { cert: cert })
  67       })
  68     })
  69   }
  70
  71   pods.addVideoToFriends = function (video) {
  72     // To avoid duplicates
  73     var id = video.name + video.magnetUri
  74     poolRequests.addToPoolRequests(id, 'add', video)
  75   }
  76
  77   pods.removeVideoToFriends = function (video) {
  78     // To avoid duplicates
  79     var id = video.name + video.magnetUri
  80     poolRequests.addToPoolRequests(id, 'remove', video)
  81   }
  82
  83   pods.makeFriends = function (callback) {
  84     var pods_score = {}
  85
  86     logger.info('Make friends!')
  87     fs.readFile(utils.certDir + 'peertube.pub', 'utf8', function (err, cert) {
  88       if (err) {
  89         logger.error('Cannot read public cert.', { error: err })
  90         return callback(err)
  91       }
  92
  93       var urls = config.get('network.friends')
  94
  95       async.each(urls, computeForeignPodsList, function () {
  96         logger.debug('Pods scores computed.', { pods_score: pods_score })
  97         var pods_list = computeWinningPods(urls, pods_score)
  98         logger.debug('Pods that we keep computed.', { pods_to_keep: pods_list })
  99
 100         logger.debug('Make requests...')
 101         makeRequestsToWinningPods(cert, pods_list)
 102       })
 103     })
 104
 105     // -----------------------------------------------------------------------
 106
 107     function computeForeignPodsList (url, callback) {
 108       // Let's give 1 point to the pod we ask the friends list
 109       pods_score[url] = 1
 110
 111       getForeignPodsList(url, function (foreign_pods_list) {
 112         if (foreign_pods_list.length === 0) return callback()
 113
 114         async.each(foreign_pods_list, function (foreign_pod, callback_each) {
 115           var foreign_url = foreign_pod.url
 116
 117           if (pods_score[foreign_url]) pods_score[foreign_url]++
 118           else pods_score[foreign_url] = 1
 119
 120           callback_each()
 121         }, function () {
 122           callback()
 123         })
 124       })
 125     }
 126
 127     function computeWinningPods (urls, pods_score) {
 128       // Build the list of pods to add
 129       // Only add a pod if it exists in more than a half base pods
 130       var pods_list = []
 131       var base_score = urls.length / 2
 132       Object.keys(pods_score).forEach(function (pod) {
 133         if (pods_score[pod] > base_score) pods_list.push({ url: pod })
 134       })
 135
 136       return pods_list
 137     }
 138
 139     function makeRequestsToWinningPods (cert, pods_list) {
 140       var data = {
 141         url: http + '://' + host + ':' + port,
 142         publicKey: cert
 143       }
 144
 145       utils.makeMultipleRetryRequest(
 146         { method: 'POST', path: '/api/' + global.API_VERSION + '/pods/', data: data },
 147
 148         pods_list,
 149
 150         function eachRequest (err, response, body, url, pod, callback_each_request) {
 151           // We add the pod if it responded correctly with its public certificate
 152           if (!err && response.statusCode === 200) {
 153             pods.add({ url: pod.url, publicKey: body.cert, score: global.FRIEND_BASE_SCORE }, function (err) {
 154               if (err) {
 155                 logger.error('Error with adding %s pod.', pod.url, { error: err })
 156               }
 157
 158               return callback_each_request()
 159             })
 160           } else {
 161             logger.error('Error with adding %s pod.', pod.url, { error: err || new Error('Status not 200') })
 162             return callback_each_request()
 163           }
 164         },
 165
 166         function endRequests (err) {
 167           if (err) {
 168             logger.error('There was some errors when we wanted to make friends.', { error: err })
 169             return callback(err)
 170           }
 171
 172           logger.debug('makeRequestsToWinningPods finished.')
 173           return callback(null)
 174         }
 175       )
 176     }
 177   }
 178
 179   module.exports = pods
 180 })()