dont use busy clients for inspection and retry inspection until timeout

Author: chescos

modules/Inspector.js

@@ -2,7 +2,7 @@ const config = require('config');
 const SteamUser = require('steam-user');
 const GlobalOffensive = require('globaloffensive');
 const SteamTotp = require('steam-totp');
-const _ = require('lodash');
+const async = require('async');
 const logger = require('./Logger');
 const Encryption = require('./Encryption');
 
@@ -73,31 +73,70 @@ accounts.forEach((account) => {
   clients.push({
     client,
     csgo,
+    busySince: null,
   });
 });
 
+setInterval(() => {
+  for (let i = 0; i < clients.length; i += 1) {
+    // Mark clients as not busy if they have been busy for more than 10 seconds.
+    if (clients[i].busySince && Date.now() > (clients[i].busySince + 10000)) {
+      clients[i].busySince = null;
+      logger.info(`Marked client ${i} as not busy after 10 second timeout`);
+    }
+  }
+}, 1000);
+
 class Inspector {
   static getClients() {
     return clients;
   }
 
   static inspect(url, timeoutMs = 3000) {
     return new Promise((resolve, reject) => {
-      const client = _.sample(_.filter(clients, ((x) => x.csgo.haveGCSession)));
-
-      if (_.isUndefined(client)) {
-        reject(
-          new Error('There is currently no client available with an active game coordinator connection'),
-        );
+      // We'll want a timeout of at least 1500 ms.
+      if (timeoutMs < 1500) {
+        throw new Error('The specified timeout must be at least 1500 ms');
       }
 
-      client.csgo.inspectItem(url, (item) => {
-        resolve(item);
-      });
-
+      // Make sure that the promise is rejected after the timeout.
       setTimeout(() => {
         reject(new Error(`Inspection timed out after ${timeoutMs} ms`));
       }, timeoutMs);
+
+      // Set the retry interval and the number of retries.
+      // We subtract 1000 ms from the `timeoutMs` because we'll need some time
+      // for the inspection too.
+      const retryInterval = 100;
+      const retryTimes = Math.round((timeoutMs - 1000 / retryInterval));
+
+      // Find an index of a client that is currently not busy and has a GC connection.
+      async
+        .retry({ times: retryTimes, interval: retryInterval }, async () => {
+          const index = clients.findIndex(
+            (client) => client.busySince === null && client.csgo.haveGCSession,
+          );
+
+          if (index === -1) {
+            throw new Error(
+              'There is currently no client available with an active game coordinator connection',
+            );
+          }
+
+          return index;
+        })
+        .then((index) => {
+          // Mark the client as busy so that it won't be used for other inspections.
+          // If the inspection succeeds, `busySince` will be cleared immediately.
+          // If the inspection times out, `busySince` will be cleared after within
+          // 1 second after the timeout.
+          clients[index].busySince = Date.now();
+
+          clients[index].csgo.inspectItem(url, (item) => {
+            clients[index].busySince = null;
+            resolve(item);
+          });
+        });
     });
   }
 }

util/index.js

@@ -0,0 +1 @@
+exports.sleep = (ms) => new Promise((res) => setTimeout(() => res(), ms));