server/models/pod.js

   1 'use strict'
   2
   3 const each = require('async/each')
   4 const map = require('lodash/map')
   5 const waterfall = require('async/waterfall')
   6
   7 const constants = require('../initializers/constants')
   8 const logger = require('../helpers/logger')
   9 const customPodsValidators = require('../helpers/custom-validators').pods
  10
  11 // ---------------------------------------------------------------------------
  12
  13 module.exports = function (sequelize, DataTypes) {
  14   const Pod = sequelize.define('Pod',
  15     {
  16       host: {
  17         type: DataTypes.STRING,
  18         allowNull: false,
  19         validate: {
  20           isHost: function (value) {
  21             const res = customPodsValidators.isHostValid(value)
  22             if (res === false) throw new Error('Host not valid.')
  23           }
  24         }
  25       },
  26       publicKey: {
  27         type: DataTypes.STRING(5000),
  28         allowNull: false
  29       },
  30       score: {
  31         type: DataTypes.INTEGER,
  32         defaultValue: constants.FRIEND_SCORE.BASE,
  33         allowNull: false,
  34         validate: {
  35           isInt: true,
  36           max: constants.FRIEND_SCORE.MAX
  37         }
  38       },
  39       email: {
  40         type: DataTypes.STRING(400),
  41         allowNull: false,
  42         validate: {
  43           isEmail: true
  44         }
  45       }
  46     },
  47     {
  48       indexes: [
  49         {
  50           fields: [ 'host' ],
  51           unique: true
  52         },
  53         {
  54           fields: [ 'score' ]
  55         }
  56       ],
  57       classMethods: {
  58         associate,
  59
  60         countAll,
  61         incrementScores,
  62         list,
  63         listAllIds,
  64         listRandomPodIdsWithRequest,
  65         listBadPods,
  66         load,
  67         loadByHost,
  68         updatePodsScore,
  69         removeAll
  70       },
  71       instanceMethods: {
  72         toFormatedJSON
  73       }
  74     }
  75   )
  76
  77   return Pod
  78 }
  79
  80 // ------------------------------ METHODS ------------------------------
  81
  82 function toFormatedJSON () {
  83   const json = {
  84     id: this.id,
  85     host: this.host,
  86     email: this.email,
  87     score: this.score,
  88     createdAt: this.createdAt
  89   }
  90
  91   return json
  92 }
  93
  94 // ------------------------------ Statics ------------------------------
  95
  96 function associate (models) {
  97   this.belongsToMany(models.Request, {
  98     foreignKey: 'podId',
  99     through: models.RequestToPod,
 100     onDelete: 'cascade'
 101   })
 102 }
 103
 104 function countAll (callback) {
 105   return this.count().asCallback(callback)
 106 }
 107
 108 function incrementScores (ids, value, callback) {
 109   if (!callback) callback = function () {}
 110
 111   const update = {
 112     score: this.sequelize.literal('score +' + value)
 113   }
 114
 115   const options = {
 116     where: {
 117       id: {
 118         $in: ids
 119       }
 120     },
 121     // In this case score is a literal and not an integer so we do not validate it
 122     validate: false
 123   }
 124
 125   return this.update(update, options).asCallback(callback)
 126 }
 127
 128 function list (callback) {
 129   return this.findAll().asCallback(callback)
 130 }
 131
 132 function listAllIds (transaction, callback) {
 133   if (!callback) {
 134     callback = transaction
 135     transaction = null
 136   }
 137
 138   const query = {
 139     attributes: [ 'id' ]
 140   }
 141
 142   if (transaction) query.transaction = transaction
 143
 144   return this.findAll(query).asCallback(function (err, pods) {
 145     if (err) return callback(err)
 146
 147     return callback(null, map(pods, 'id'))
 148   })
 149 }
 150
 151 function listRandomPodIdsWithRequest (limit, tableRequestPod, callback) {
 152   const self = this
 153
 154   self.count().asCallback(function (err, count) {
 155     if (err) return callback(err)
 156
 157     // Optimization...
 158     if (count === 0) return callback(null, [])
 159
 160     let start = Math.floor(Math.random() * count) - limit
 161     if (start < 0) start = 0
 162
 163     const query = {
 164       attributes: [ 'id' ],
 165       order: [
 166         [ 'id', 'ASC' ]
 167       ],
 168       offset: start,
 169       limit: limit,
 170       where: {
 171         id: {
 172           $in: [
 173             this.sequelize.literal('SELECT "podId" FROM "' + tableRequestPod + '"')
 174           ]
 175         }
 176       }
 177     }
 178
 179     return this.findAll(query).asCallback(function (err, pods) {
 180       if (err) return callback(err)
 181
 182       return callback(null, map(pods, 'id'))
 183     })
 184   })
 185 }
 186
 187 function listBadPods (callback) {
 188   const query = {
 189     where: {
 190       score: { $lte: 0 }
 191     }
 192   }
 193
 194   return this.findAll(query).asCallback(callback)
 195 }
 196
 197 function load (id, callback) {
 198   return this.findById(id).asCallback(callback)
 199 }
 200
 201 function loadByHost (host, callback) {
 202   const query = {
 203     where: {
 204       host: host
 205     }
 206   }
 207
 208   return this.findOne(query).asCallback(callback)
 209 }
 210
 211 function removeAll (callback) {
 212   return this.destroy().asCallback(callback)
 213 }
 214
 215 function updatePodsScore (goodPods, badPods) {
 216   const self = this
 217
 218   logger.info('Updating %d good pods and %d bad pods scores.', goodPods.length, badPods.length)
 219
 220   if (goodPods.length !== 0) {
 221     this.incrementScores(goodPods, constants.PODS_SCORE.BONUS, function (err) {
 222       if (err) logger.error('Cannot increment scores of good pods.', { error: err })
 223     })
 224   }
 225
 226   if (badPods.length !== 0) {
 227     this.incrementScores(badPods, constants.PODS_SCORE.MALUS, function (err) {
 228       if (err) logger.error('Cannot decrement scores of bad pods.', { error: err })
 229       removeBadPods.call(self)
 230     })
 231   }
 232 }
 233
 234 // ---------------------------------------------------------------------------
 235
 236 // Remove pods with a score of 0 (too many requests where they were unreachable)
 237 function removeBadPods () {
 238   const self = this
 239
 240   waterfall([
 241     function findBadPods (callback) {
 242       self.sequelize.models.Pod.listBadPods(function (err, pods) {
 243         if (err) {
 244           logger.error('Cannot find bad pods.', { error: err })
 245           return callback(err)
 246         }
 247
 248         return callback(null, pods)
 249       })
 250     },
 251
 252     function removeTheseBadPods (pods, callback) {
 253       each(pods, function (pod, callbackEach) {
 254         pod.destroy().asCallback(callbackEach)
 255       }, function (err) {
 256         return callback(err, pods.length)
 257       })
 258     }
 259   ], function (err, numberOfPodsRemoved) {
 260     if (err) {
 261       logger.error('Cannot remove bad pods.', { error: err })
 262     } else if (numberOfPodsRemoved) {
 263       logger.info('Removed %d pods.', numberOfPodsRemoved)
 264     } else {
 265       logger.info('No need to remove bad pods.')
 266     }
 267   })
 268 }