X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fserver%2Fserver.ts;h=a5e05f460fffcfe90c8026321f6df023c513b121;hb=5e47f6ab984a7d00782e4c7030afffa1ba480add;hp=d35aa0ca402222f3ec6a2c54bdf371739867846f;hpb=da854ddd502cd70685ef779c673b9e63757b8aa0;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/models/server/server.ts b/server/models/server/server.ts
index d35aa0ca4..a5e05f460 100644
--- a/server/models/server/server.ts
+++ b/server/models/server/server.ts
@@ -1,9 +1,11 @@
-import * as Sequelize from 'sequelize'
-import { AllowNull, Column, CreatedAt, Default, Is, IsInt, Max, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { Transaction } from 'sequelize'
+import { AllowNull, Column, CreatedAt, Default, HasMany, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { MServer, MServerFormattable } from '@server/types/models/server'
+import { AttributesOnly } from '@shared/typescript-utils'
 import { isHostValid } from '../../helpers/custom-validators/servers'
-import { logger } from '../../helpers/logger'
-import { SERVERS_SCORE } from '../../initializers'
-import { throwIfNotValid } from '../utils'
+import { ActorModel } from '../actor/actor'
+import { buildSQLAttributes, throwIfNotValid } from '../shared'
+import { ServerBlocklistModel } from './server-blocklist'
 
 @Table({
   tableName: 'server',
@@ -11,13 +13,10 @@ import { throwIfNotValid } from '../utils'
     {
       fields: [ 'host' ],
       unique: true
-    },
-    {
-      fields: [ 'score' ]
     }
   ]
 })
-export class ServerModel extends Model<ServerModel> {
+export class ServerModel extends Model<Partial<AttributesOnly<ServerModel>>> {
 
   @AllowNull(false)
   @Is('Host', value => throwIfNotValid(value, isHostValid, 'valid host'))
@@ -25,11 +24,9 @@ export class ServerModel extends Model<ServerModel> {
   host: string
 
   @AllowNull(false)
-  @Default(SERVERS_SCORE.BASE)
-  @IsInt
-  @Max(SERVERS_SCORE.MAX)
+  @Default(false)
   @Column
-  score: number
+  redundancyAllowed: boolean
 
   @CreatedAt
   createdAt: Date
@@ -37,73 +34,71 @@ export class ServerModel extends Model<ServerModel> {
   @UpdatedAt
   updatedAt: Date
 
-  static updateServersScoreAndRemoveBadOnes (goodServers: number[], badServers: number[]) {
-    logger.info('Updating %d good servers and %d bad servers scores.', goodServers.length, badServers.length)
-
-    if (goodServers.length !== 0) {
-      ServerModel.incrementScores(goodServers, SERVERS_SCORE.BONUS)
-        .catch(err => {
-          logger.error('Cannot increment scores of good servers.', err)
-        })
-    }
-
-    if (badServers.length !== 0) {
-      ServerModel.incrementScores(badServers, SERVERS_SCORE.PENALTY)
-        .then(() => ServerModel.removeBadServers())
-        .catch(err => {
-          if (err) logger.error('Cannot decrement scores of bad servers.', err)
-        })
-
-    }
-  }
-
-  // Remove servers with a score of 0 (too many requests where they were unreachable)
-  private static async removeBadServers () {
-    try {
-      const servers = await ServerModel.listBadServers()
-
-      const serversRemovePromises = servers.map(server => server.destroy())
-      await Promise.all(serversRemovePromises)
-
-      const numberOfServersRemoved = servers.length
-
-      if (numberOfServersRemoved) {
-        logger.info('Removed %d servers.', numberOfServersRemoved)
-      } else {
-        logger.info('No need to remove bad servers.')
-      }
-    } catch (err) {
-      logger.error('Cannot remove bad servers.', err)
-    }
+  @HasMany(() => ActorModel, {
+    foreignKey: {
+      name: 'serverId',
+      allowNull: true
+    },
+    onDelete: 'CASCADE',
+    hooks: true
+  })
+  Actors: ActorModel[]
+
+  @HasMany(() => ServerBlocklistModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+  BlockedBy: ServerBlocklistModel[]
+
+  // ---------------------------------------------------------------------------
+
+  static getSQLAttributes (tableName: string, aliasPrefix = '') {
+    return buildSQLAttributes({
+      model: this,
+      tableName,
+      aliasPrefix
+    })
   }
 
-  private static incrementScores (ids: number[], value: number) {
-    const update = {
-      score: Sequelize.literal('score +' + value)
-    }
+  // ---------------------------------------------------------------------------
 
-    const options = {
+  static load (id: number, transaction?: Transaction): Promise<MServer> {
+    const query = {
       where: {
-        id: {
-          [Sequelize.Op.in]: ids
-        }
+        id
       },
-      // In this case score is a literal and not an integer so we do not validate it
-      validate: false
+      transaction
     }
 
-    return ServerModel.update(update, options)
+    return ServerModel.findOne(query)
   }
 
-  private static listBadServers () {
+  static loadByHost (host: string): Promise<MServer> {
     const query = {
       where: {
-        score: {
-          [Sequelize.Op.lte]: 0
-        }
+        host
       }
     }
 
-    return ServerModel.findAll(query)
+    return ServerModel.findOne(query)
+  }
+
+  static async loadOrCreateByHost (host: string) {
+    let server = await ServerModel.loadByHost(host)
+    if (!server) server = await ServerModel.create({ host })
+
+    return server
+  }
+
+  isBlocked () {
+    return this.BlockedBy && this.BlockedBy.length !== 0
+  }
+
+  toFormattedJSON (this: MServerFormattable) {
+    return {
+      host: this.host
+    }
   }
 }