feat: db replication

isd-sgcu · Mar 30, 2024 · 9885c31 · 9885c31
1 parent cc099d7
commit 9885c31
Show file tree

Hide file tree

Showing 8 changed files with 70 additions and 37 deletions.
diff --git a/apps/server/src/controller/admin.controller.ts b/apps/server/src/controller/admin.controller.ts
@@ -8,7 +8,7 @@ export class AdminController {
   constructor(
     private readonly io: Server,
     private readonly adminService: AdminService,
-  ) { }
+  ) {}
   async listGames(req: Request, res: Response) {
     const games = await this.adminService.listGames()
     res.json(games)
@@ -41,7 +41,13 @@ export class AdminController {
       'state',
       await this.adminService.getGameState().then((game) => game.id),
     )
-    this.io.sockets.to('scoreboard').emit('scoreboard', await this.adminService.getScoreboard(game.id, game.actions.map((a) => a.key)))
+    this.io.sockets.to('scoreboard').emit(
+      'scoreboard',
+      await this.adminService.getScoreboard(
+        game.id,
+        game.actions.map((a) => a.key),
+      ),
+    )
   }
 
   async endGame(req: Request, res: Response) {
@@ -58,7 +64,10 @@ export class AdminController {
   async getGameSummary(req: Request, res: Response) {
     const game = await this.adminService.getGameByID(req.params.id)
     if (!game) return res.status(404).send({ err: 'Game not found' })
-    const summary = await this.adminService.getGameSummary(game.id, game.actions.map((a) => a.key))
+    const summary = await this.adminService.getGameSummary(
+      game.id,
+      game.actions.map((a) => a.key),
+    )
     res.json(summary)
   }
 

diff --git a/apps/server/src/controller/player.controller.ts b/apps/server/src/controller/player.controller.ts
@@ -8,8 +8,7 @@ export class PlayerController {
   constructor(
     private readonly io: Server,
     private readonly playerService: PlayerService,
-  ) {
-  }
+  ) {}
 
   async authenticateSocket(socket: Socket) {
     const cid = (socket.handshake.headers.cid ||
@@ -55,36 +54,41 @@ export class PlayerController {
     })
 
     socket.on('subscribe', (m, cb) => {
-      socket.join('scoreboard');
+      socket.join('scoreboard')
       this.playerService.getGameState().then((game) => {
         if (game.id && game.game && game.status === 'playing')
           this.playerService
-            .getScoreboard(game.id, game.game.actions.map((a) => a.key))
+            .getScoreboard(
+              game.id,
+              game.game.actions.map((a) => a.key),
+            )
             .then((score) => {
               socket.emit('scoreboard', score)
             })
       })
     })
 
     socket.on('submit', async (message) => {
-      this.logger.debug("Received message: " + String(message).trim())
+      this.logger.debug('Received message: ' + String(message).trim())
       const data = String(message).trim().split(' ')
       this.playerService
         .submit(socket.user, data[0], parseInt(data[1]))
         .then((game) => {
           this.logger.debug(`Incremented: ${String(message).trim()}`)
           if (game.id && game.game) {
-            this.logger.debug("Getting scoreboard updated")
+            this.logger.debug('Getting scoreboard updated')
             return this.playerService
-              .getScoreboard(game.id, game.game.actions.map((a) => a.key))
+              .getScoreboard(
+                game.id,
+                game.game.actions.map((a) => a.key),
+              )
               .then((score) =>
                 this.io.to('scoreboard').emit('scoreboard', score),
               )
           }
-        }
-        )
+        })
         .catch((err) => {
-          this.logger.warn("Failed to increment: " + err)
+          this.logger.warn('Failed to increment: ' + err)
           socket.disconnect(true)
         })
     })

diff --git a/apps/server/src/models/game.model.ts b/apps/server/src/models/game.model.ts
@@ -5,7 +5,8 @@ import { GameHistory } from './history.model'
 
 export class Game
   extends Model<GameAttributes, GameInput>
-  implements GameAttributes {
+  implements GameAttributes
+{
   public id!: string
   public title!: string
   public description!: string

diff --git a/apps/server/src/models/history.model.ts b/apps/server/src/models/history.model.ts
@@ -15,7 +15,8 @@ import { Game } from './game.model'
 
 export class GameHistory
   extends Model<GameHistoryAttributes, GameHistoryInput>
-  implements GameHistoryAttributes {
+  implements GameHistoryAttributes
+{
   public game_id!: string
   public player_id!: string
   public key!: string
@@ -58,7 +59,7 @@ export class GameHistoryRepository {
       RedisFunctions,
       RedisScripts
     >,
-  ) { }
+  ) {}
 
   async createHistory(
     game_id: string,
@@ -70,8 +71,8 @@ export class GameHistoryRepository {
     this.redis.keys(`game::${game_id}::*`).then(async (keys) => {
       keys.forEach(async (k) => {
         if (k !== `game::${game_id}::${key}`) {
-          const kTotal = parseInt(await this.redis.get(k) || '0')
-          const decrease = ((Math.floor(Math.abs(total - kTotal) * vote / 100)))
+          const kTotal = parseInt((await this.redis.get(k)) || '0')
+          const decrease = Math.floor((Math.abs(total - kTotal) * vote) / 100)
           const remain = kTotal - decrease
           if (remain > 0) this.redis.decrBy(k, decrease)
         }
@@ -147,5 +148,4 @@ export class GameHistoryRepository {
       }))
     })
   }
-
 }
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
@@ -41,7 +41,8 @@ export async function initServer(app: Express, server: HTTPServer) {
       logger.info(' Database Connection has been established successfully.')
     })
     .catch((err) => {
-      logger.error('Unable to connect to the database:', { err })
+      console.error(err)
+      logger.error(`Unable to connect to the database: ${err}`)
     })
   sequelizeConnection.sync({ force: process.env.FORCE_DB_SYNC === 'true' })
 

diff --git a/apps/server/src/service/admin.service.ts b/apps/server/src/service/admin.service.ts
@@ -5,7 +5,7 @@ export class AdminService {
   constructor(
     private readonly gameRepository: GameRepository,
     private readonly gameHistoryRepository: GameHistoryRepository,
-  ) { }
+  ) {}
 
   async getGameByID(id: string) {
     return this.gameRepository.getGameById(id)
@@ -42,9 +42,13 @@ export class AdminService {
       .then((score) => {
         const total_vote = score.reduce((acc, s) => acc + s.vote, 0)
         if (total_vote === 0) {
-          return score.map((s) => `${s.key} ${(100 / score.length).toFixed(2)}`).join(' ')
+          return score
+            .map((s) => `${s.key} ${(100 / score.length).toFixed(2)}`)
+            .join(' ')
         }
-        return score?.map((s) => `${s.key} ${(s.vote / total_vote * 100).toFixed(2)}`).join(' ')
+        return score
+          ?.map((s) => `${s.key} ${((s.vote / total_vote) * 100).toFixed(2)}`)
+          .join(' ')
       })
   }
 

diff --git a/apps/server/src/service/player.service.ts b/apps/server/src/service/player.service.ts
@@ -9,7 +9,7 @@ export class PlayerService {
     private readonly gameRepository: GameRepository,
     private readonly clientRepository: ClientRepository,
     private readonly gameHistoryRepository: GameHistoryRepository,
-  ) { }
+  ) {}
 
   async getGame(id: string) {
     return await this.gameRepository.getGameById(id).catch((err) => ({ err }))
@@ -80,9 +80,13 @@ export class PlayerService {
       .then((score) => {
         const total_vote = score.reduce((acc, s) => acc + s.vote, 0)
         if (total_vote === 0) {
-          return score.map((s) => `${s.key} ${(100 / score.length).toFixed(2)}`).join(' ')
+          return score
+            .map((s) => `${s.key} ${(100 / score.length).toFixed(2)}`)
+            .join(' ')
         }
-        return score?.map((s) => `${s.key} ${(s.vote / total_vote * 100).toFixed(2)}`).join(' ')
+        return score
+          ?.map((s) => `${s.key} ${((s.vote / total_vote) * 100).toFixed(2)}`)
+          .join(' ')
       })
   }
 }
diff --git a/apps/server/src/utils/database.ts b/apps/server/src/utils/database.ts
@@ -1,18 +1,28 @@
 import { Sequelize } from 'sequelize'
 
 function createConnectionPool() {
-  return new Sequelize({
-    host: process.env.DB_HOST || 'db',
-    database: process.env.DB_NAME || 'cutu',
-    username: process.env.DB_USER || 'postgres',
-    password: process.env.DB_PASSWORD || 'postgres',
-    port: parseInt(process.env.DB_PORT || '5432'),
-    dialect: 'postgres',
-    sync: {
-      force: (process.env.NODE_ENV || 'development') !== 'production',
+  return new Sequelize(
+    process.env.DB_NAME || 'cutu',
+    process.env.DB_USER || 'postgres',
+    process.env.DB_PASS || 'postgres',
+    {
+      port: parseInt(process.env.DB_PORT || '5432'),
+      dialect: 'postgres',
+      replication: {
+        read: [
+          ...(process.env.DB_READ_HOST?.split(',').map((url) => ({
+            host: url,
+          })) || []),
+          { host: process.env.DB_HOST || 'db' },
+        ],
+        write: { host: process.env.DB_HOST || 'db' },
+      },
+      sync: {
+        force: (process.env.NODE_ENV || 'development') !== 'production',
+      },
+      logging: false,
     },
-    logging: false,
-  })
+  )
 }
 
 export const sequelizeConnection = createConnectionPool()