chore: optimize assigning servers

Author: lukepolo

src/matches/events/KnifeSwitch.ts

@@ -27,6 +27,7 @@ export default class KnifeSwitch extends MatchEventProcessor<void> {
             id: match.current_match_map_id,
           },
           _set: {
+            status: "Live",
             lineup_1_side: currentMap.lineup_2_side,
             lineup_2_side: currentMap.lineup_1_side,
           },

src/matches/match-assistant/match-assistant.service.ts

@@ -154,7 +154,9 @@ export class MatchAssistantService {
     return matches_by_pk.server;
   }
 
-  public async isDedicatedServerAvailable(matchId: string): Promise<boolean> {
+  public async isDedicatedServerAvailable(
+    matchId: string,
+  ): Promise<string | undefined> {
     const server = await this.getMatchServer(matchId);
 
     if (!server) {
@@ -189,7 +191,9 @@ export class MatchAssistantService {
       throw Error("unable to find server");
     }
 
-    return servers_by_pk.matches_aggregate.aggregate?.count === 0;
+    return (
+      servers_by_pk.matches_aggregate.aggregate?.count === 0 && servers_by_pk.id
+    );
   }
 
   public async updateMatchStatus(matchId: string, status: e_match_status_enum) {
@@ -208,7 +212,7 @@ export class MatchAssistantService {
     });
   }
 
-  public async assignServer(matchId: string, tries = 0): Promise<boolean> {
+  public async assignServer(matchId: string, tries = 0): Promise<void> {
     const { matches_by_pk: match } = await this.hasura.query({
       matches_by_pk: {
         __args: {
@@ -229,14 +233,16 @@ export class MatchAssistantService {
       );
 
       if (assignedDedicated) {
-        return true;
+        await this.startMatch(matchId);
+        return;
       }
     }
 
     try {
       const isAssignedOnDemand = await this.assignOnDemandServer(matchId);
       if (isAssignedOnDemand) {
-        return true;
+        await this.startMatch(matchId);
+        return;
       }
     } catch (error) {
       this.logger.error(
@@ -248,7 +254,7 @@ export class MatchAssistantService {
           this.logger.log(`[${matchId}] try retry assign server....`);
           await this.assignServer(matchId, ++tries);
         }, tries * 1000);
-        return false;
+        return;
       }
     }
 
@@ -258,19 +264,53 @@ export class MatchAssistantService {
         `[${matchId}] unable to assign dedicated server, trying on demand`,
       );
       await this.updateMatchStatus(match.id, "WaitingForServer");
-      return false;
+      return;
     }
 
     if (await this.assignDedicatedServer(match.id, match.region)) {
-      return true;
+      await this.startMatch(matchId);
+      return;
     }
 
     this.logger.log(
       `[${matchId}] unable to assign dedicated server, updating match status to waiting for server`,
     );
+
     await this.updateMatchStatus(match.id, "WaitingForServer");
+  }
+
+  private async startMatch(matchId: string) {
+    await this.updateMatchStatus(matchId, "Live");
+
+    await this.sendServerMatchId(matchId);
+  }
+
+  public async reserveDedicatedServer(matchId: string) {
+    const serverId = await this.isDedicatedServerAvailable(matchId);
+    if (!serverId) {
+      this.logger.warn(
+        `[${matchId}] another match is currently live, moving back to scheduled`,
+      );
+      await this.updateMatchStatus(matchId, "WaitingForServer");
+
+      return;
+    }
+
+    await this.hasura.mutation({
+      update_servers_by_pk: {
+        __args: {
+          pk_columns: {
+            id: serverId,
+          },
+          _set: {
+            reserved_by_match_id: matchId,
+          },
+        },
+        __typename: true,
+      },
+    });
 
-    return false;
+    await this.startMatch(matchId);
   }
 
   private async assignDedicatedServer(

src/matches/matches.controller.ts

@@ -388,6 +388,7 @@ export class MatchesController {
         server: {
           id: true,
           is_dedicated: true,
+          reserved_by_match_id: true,
           game_server_node_id: true,
         },
       },
@@ -399,33 +400,13 @@ export class MatchesController {
 
     if (status === "Live" && data.old.status !== "WaitingForServer") {
       if (match.server) {
-        if (
-          match.server.is_dedicated &&
-          !(await this.matchAssistant.isDedicatedServerAvailable(matchId))
-        ) {
-          this.logger.warn(
-            `[${matchId}] another match is currently live, moving back to scheduled`,
-          );
-          await this.matchAssistant.updateMatchStatus(
-            match.id,
-            "WaitingForServer",
-          );
+        if (match.server.reserved_by_match_id === matchId) {
           return;
         }
 
-        await this.hasura.mutation({
-          update_servers_by_pk: {
-            __args: {
-              pk_columns: {
-                id: match.server.id,
-              },
-              _set: {
-                reserved_by_match_id: matchId,
-              },
-            },
-            __typename: true,
-          },
-        });
+        if (match.server.is_dedicated) {
+          await this.matchAssistant.reserveDedicatedServer(matchId);
+        }
       } else {
         /**
          * if we don't have a server id it means we need to assign it one
@@ -434,10 +415,6 @@ export class MatchesController {
       }
     }
 
-    if (match.server?.id) {
-      await this.matchAssistant.sendServerMatchId(matchId);
-    }
-
     await this.discordMatchOverview.updateMatchOverview(matchId);
   }
 
@@ -547,10 +524,6 @@ export class MatchesController {
       );
     }
 
-    if (updated_match.server?.game_server_node_id === null) {
-      await this.matchAssistant.sendServerMatchId(match_id);
-    }
-
     return {
       success: true,
     };
@@ -825,11 +798,7 @@ export class MatchesController {
       return;
     }
 
-    if (!(await this.matchAssistant.assignServer(match.id))) {
-      return;
-    }
-
-    await this.matchAssistant.updateMatchStatus(match.id, "Live");
+    await this.matchAssistant.assignServer(match.id);
   }
 
   @HasuraEvent()
@@ -895,10 +864,7 @@ export class MatchesController {
     });
 
     for (const match of matches) {
-      if (!(await this.matchAssistant.assignServer(match.id))) {
-        break;
-      }
-      await this.matchAssistant.updateMatchStatus(match.id, "Live");
+      await this.matchAssistant.assignServer(match.id);
     }
   }
 

src/type-sense/type-sense.service.ts

@@ -235,10 +235,12 @@ export class TypeSenseService {
       },
     });
 
-    for (const matchLineupPlayer of match_lineup_players) {
-      await this.matchAssistant.sendServerMatchId(
-        matchLineupPlayer.lineup.v_match_lineup.match_id,
-      );
+    if (player.is_banned || player.is_gagged || player.is_muted) {
+      for (const matchLineupPlayer of match_lineup_players) {
+        await this.matchAssistant.sendServerMatchId(
+          matchLineupPlayer.lineup.v_match_lineup.match_id,
+        );
+      }
     }
 
     // this is to allow filtering