PeerTube/server/models/pod/pod.ts

252 lines
5.6 KiB
TypeScript
Raw Normal View History

2017-05-15 22:22:03 +02:00
import { map } from 'lodash'
2017-05-22 20:58:25 +02:00
import * as Sequelize from 'sequelize'
2017-06-16 09:45:46 +02:00
import { FRIEND_SCORE, PODS_SCORE } from '../../initializers'
import { logger, isHostValid } from '../../helpers'
2017-06-16 09:45:46 +02:00
import { addMethodsToModel } from '../utils'
2017-05-22 20:58:25 +02:00
import {
PodInstance,
PodAttributes,
PodMethods
} from './pod-interface'
let Pod: Sequelize.Model<PodInstance, PodAttributes>
let toFormatedJSON: PodMethods.ToFormatedJSON
let countAll: PodMethods.CountAll
let incrementScores: PodMethods.IncrementScores
let list: PodMethods.List
let listAllIds: PodMethods.ListAllIds
let listRandomPodIdsWithRequest: PodMethods.ListRandomPodIdsWithRequest
let listBadPods: PodMethods.ListBadPods
let load: PodMethods.Load
let loadByHost: PodMethods.LoadByHost
let removeAll: PodMethods.RemoveAll
let updatePodsScore: PodMethods.UpdatePodsScore
2017-06-11 17:35:32 +02:00
export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
Pod = sequelize.define<PodInstance, PodAttributes>('Pod',
2016-12-11 21:50:51 +01:00
{
host: {
2016-12-28 15:49:23 +01:00
type: DataTypes.STRING,
allowNull: false,
validate: {
isHost: function (value) {
2017-05-15 22:22:03 +02:00
const res = isHostValid(value)
2016-12-28 15:49:23 +01:00
if (res === false) throw new Error('Host not valid.')
}
}
2016-12-11 21:50:51 +01:00
},
publicKey: {
2016-12-28 15:49:23 +01:00
type: DataTypes.STRING(5000),
allowNull: false
2016-12-11 21:50:51 +01:00
},
score: {
type: DataTypes.INTEGER,
2017-05-15 22:22:03 +02:00
defaultValue: FRIEND_SCORE.BASE,
2016-12-28 15:49:23 +01:00
allowNull: false,
validate: {
isInt: true,
2017-05-15 22:22:03 +02:00
max: FRIEND_SCORE.MAX
2016-12-28 15:49:23 +01:00
}
2017-02-16 19:19:56 +01:00
},
email: {
type: DataTypes.STRING(400),
2017-02-18 09:29:59 +01:00
allowNull: false,
validate: {
isEmail: true
}
2016-12-11 21:50:51 +01:00
}
},
{
2016-12-29 09:33:28 +01:00
indexes: [
{
2017-02-16 19:24:34 +01:00
fields: [ 'host' ],
unique: true
2016-12-29 09:33:28 +01:00
},
{
fields: [ 'score' ]
}
2017-05-22 20:58:25 +02:00
]
2016-12-11 21:50:51 +01:00
}
)
2017-05-22 20:58:25 +02:00
const classMethods = [
associate,
countAll,
incrementScores,
list,
listAllIds,
listRandomPodIdsWithRequest,
listBadPods,
load,
loadByHost,
updatePodsScore,
removeAll
]
const instanceMethods = [ toFormatedJSON ]
addMethodsToModel(Pod, classMethods, instanceMethods)
2016-12-11 21:50:51 +01:00
return Pod
}
// ------------------------------ METHODS ------------------------------
toFormatedJSON = function (this: PodInstance) {
const json = {
2016-12-11 21:50:51 +01:00
id: this.id,
host: this.host,
2017-02-16 19:19:56 +01:00
email: this.email,
score: this.score as number,
2016-12-11 21:50:51 +01:00
createdAt: this.createdAt
}
return json
}
// ------------------------------ Statics ------------------------------
2016-12-11 21:50:51 +01:00
function associate (models) {
2017-05-22 20:58:25 +02:00
Pod.belongsToMany(models.Request, {
2016-12-11 21:50:51 +01:00
foreignKey: 'podId',
through: models.RequestToPod,
2016-12-24 16:59:17 +01:00
onDelete: 'cascade'
2016-12-11 21:50:51 +01:00
})
}
countAll = function () {
return Pod.count()
}
incrementScores = function (ids: number[], value: number) {
2016-12-11 21:50:51 +01:00
const update = {
2017-05-22 20:58:25 +02:00
score: Sequelize.literal('score +' + value)
2016-12-11 21:50:51 +01:00
}
2016-12-28 15:49:23 +01:00
const options = {
2016-12-11 21:50:51 +01:00
where: {
id: {
$in: ids
}
2016-12-28 15:49:23 +01:00
},
// In this case score is a literal and not an integer so we do not validate it
validate: false
2016-12-11 21:50:51 +01:00
}
return Pod.update(update, options)
}
list = function () {
return Pod.findAll()
}
2015-06-09 17:41:40 +02:00
listAllIds = function (transaction: Sequelize.Transaction) {
const query: Sequelize.FindOptions = {
attributes: [ 'id' ],
transaction
2016-12-11 21:50:51 +01:00
}
return Pod.findAll(query).then(pods => {
return map(pods, 'id')
})
}
listRandomPodIdsWithRequest = function (limit: number, tableWithPods: string, tableWithPodsJoins: string) {
return Pod.count().then(count => {
2017-01-10 22:24:42 +01:00
// Optimization...
if (count === 0) return []
2017-01-10 22:24:42 +01:00
let start = Math.floor(Math.random() * count) - limit
if (start < 0) start = 0
const query = {
attributes: [ 'id' ],
order: [
[ 'id', 'ASC' ]
],
offset: start,
limit: limit,
where: {
id: {
$in: [
2017-05-22 20:58:25 +02:00
Sequelize.literal(`SELECT DISTINCT "${tableWithPods}"."podId" FROM "${tableWithPods}" ${tableWithPodsJoins}`)
2017-01-10 22:24:42 +01:00
]
}
}
}
return Pod.findAll(query).then(pods => {
return map(pods, 'id')
2017-01-10 22:24:42 +01:00
})
})
}
listBadPods = function () {
2016-12-11 21:50:51 +01:00
const query = {
where: {
score: { $lte: 0 }
}
}
return Pod.findAll(query)
}
2015-06-09 17:41:40 +02:00
load = function (id: number) {
return Pod.findById(id)
}
2016-01-31 11:23:52 +01:00
loadByHost = function (host: string) {
2016-12-11 21:50:51 +01:00
const query = {
where: {
host: host
}
}
return Pod.findOne(query)
}
2016-01-31 11:23:52 +01:00
removeAll = function () {
return Pod.destroy()
}
2017-06-10 22:15:25 +02:00
updatePodsScore = function (goodPods: number[], badPods: number[]) {
logger.info('Updating %d good pods and %d bad pods scores.', goodPods.length, badPods.length)
if (goodPods.length !== 0) {
incrementScores(goodPods, PODS_SCORE.BONUS).catch(err => {
logger.error('Cannot increment scores of good pods.', { error: err })
})
}
if (badPods.length !== 0) {
incrementScores(badPods, PODS_SCORE.MALUS)
.then(() => removeBadPods())
.catch(err => {
if (err) logger.error('Cannot decrement scores of bad pods.', { error: err })
})
}
}
// ---------------------------------------------------------------------------
// Remove pods with a score of 0 (too many requests where they were unreachable)
function removeBadPods () {
return listBadPods()
.then(pods => {
const podsRemovePromises = pods.map(pod => pod.destroy())
return Promise.all(podsRemovePromises).then(() => pods.length)
})
.then(numberOfPodsRemoved => {
if (numberOfPodsRemoved) {
logger.info('Removed %d pods.', numberOfPodsRemoved)
} else {
logger.info('No need to remove bad pods.')
}
})
.catch(err => {
logger.error('Cannot remove bad pods.', { error: err })
})
}