Use sc api for healthcheck

Author: budziam

src/constants.js

@@ -329,7 +329,6 @@ export const SC_PARAMS_TO_STRIP = [
   ...SAUCE_CONNECT_CLI_PARAM_ALIASES,
 ];
 
-export const SC_READY_MESSAGE = 'Sauce Connect is up, you may start your tests';
-export const SC_FAILURE_MESSAGES = ['fatal error exiting'];
-export const SC_CLOSE_MESSAGE = 'tunnel was shutdown';
 export const SC_CLOSE_TIMEOUT = 5000;
+export const SC_READY_TIMEOUT = 30000;
+export const SC_HEALTHCHECK_TIMEOUT = 1000;

src/index.js

@@ -30,15 +30,12 @@ import {
   SYMBOL_ITERATOR,
   TO_STRING_TAG,
   SC_PARAMS_TO_STRIP,
-  SC_READY_MESSAGE,
-  SC_CLOSE_MESSAGE,
-  SC_CLOSE_TIMEOUT,
   DEFAULT_SAUCE_CONNECT_VERSION,
-  SC_FAILURE_MESSAGES,
   SC_BOOLEAN_CLI_PARAMS,
   DEFAULT_RUNNER_NAME,
 } from './constants';
 import SauceConnectLoader from './sauceConnectLoader';
+import {SauceConnectManager} from './sauceConnectManager';
 
 export default class SauceLabs {
   constructor(options) {
@@ -259,6 +256,7 @@ export default class SauceLabs {
           ![
             '_',
             '$0',
+            'api-address',
             'metadata',
             'sc-version',
             'sc-upstream-proxy',
@@ -294,14 +292,17 @@ export default class SauceLabs {
     }
 
     // Provide a default runner name. It's used for identifying the tunnel's initiation method.
-    let metadata = argv.metadata || "";
-    if (!metadata.includes("runner=")) {
+    let metadata = argv.metadata || '';
+    if (!metadata.includes('runner=')) {
       metadata = [metadata, `runner=${DEFAULT_RUNNER_NAME}`]
         .filter(Boolean)
-        .join(',')
+        .join(',');
     }
     args.push(`--metadata=${metadata}`);
 
+    const apiAddress = argv.apiAddress || ':8032';
+    args.push(`--api-address=${apiAddress}`);
+
     const region = argv.region || this.region;
     if (region) {
       const scRegion = getRegionSubDomain({region});
@@ -338,60 +339,20 @@ export default class SauceLabs {
       args.unshift('run');
     }
 
+    const logger = fromCLI
+      ? process.stdout.write.bind(process.stdout)
+      : argv.logger;
     const cp = spawn(scLoader.path, args);
-    return new Promise((resolve, reject) => {
-      const close = () =>
-        new Promise((resolveClose) => {
-          process.kill(cp.pid, 'SIGINT');
-          const timeout = setTimeout(resolveClose, SC_CLOSE_TIMEOUT);
-          cp.stdout.on('data', (data) => {
-            const output = data.toString();
-            if (output.includes(SC_CLOSE_MESSAGE)) {
-              clearTimeout(timeout);
-              return resolveClose(returnObj);
-            }
-          });
-        });
-      const returnObj = {cp, close};
-
-      cp.stderr.on('data', (data) => {
-        const output = data.toString();
-        return reject(new Error(output));
-      });
-      cp.stdout.on('data', (data) => {
-        const logger = fromCLI
-          ? process.stdout.write.bind(process.stdout)
-          : argv.logger;
-        const output = data.toString();
-        /**
-         * print to stdout if called via CLI
-         */
-        if (typeof logger === 'function') {
-          logger(output);
-        }
-
-        /**
-         * fail if SauceConnect could not establish a connection
-         */
-        if (
-          SC_FAILURE_MESSAGES.find((msg) =>
-            escape(output).includes(escape(msg))
-          )
-        ) {
-          return reject(new Error(output));
-        }
+    const manager = new SauceConnectManager(cp, logger);
+    process.on('SIGINT', () => manager.close());
 
-        /**
-         * continue if connection was established
-         */
-        if (output.includes(SC_READY_MESSAGE)) {
-          return resolve(returnObj);
-        }
-      });
-
-      process.on('SIGINT', close);
-      return returnObj;
-    });
+    try {
+      await manager.waitForReady(apiAddress);
+      return {cp, close: () => manager.close()};
+    } catch (err) {
+      await manager.close();
+      throw err;
+    }
   }
 
   /**

src/sauceConnectManager.js

@@ -0,0 +1,98 @@
+import {
+  SC_CLOSE_TIMEOUT,
+  SC_HEALTHCHECK_TIMEOUT,
+  SC_READY_TIMEOUT,
+} from './constants';
+
+export class SauceConnectManager {
+  constructor(cp, logger) {
+    this.cp = cp;
+    this.logger = logger;
+    this._healthcheckInterval = null;
+    this._readyTimeout = null;
+  }
+
+  waitForReady(apiAddress) {
+    apiAddress = this._parseApiAddress(apiAddress);
+
+    return new Promise((resolve, reject) => {
+      this.cp.stderr.on('data', (data) => {
+        const output = data.toString();
+        return reject(new Error(output));
+      });
+
+      this.cp.stdout.on('data', (data) => {
+        const logger = this.logger;
+        if (typeof logger === 'function') {
+          logger(data.toString());
+        }
+      });
+
+      this._healthcheckInterval = setInterval(async () => {
+        if (this.cp.exitCode !== null) {
+          clearInterval(this._healthcheckInterval);
+          clearTimeout(this._readyTimeout);
+          return reject(new Error('Sauce Connect exited before ready'));
+        }
+
+        this._callHealthcheckEndpoint(apiAddress)
+          .then(() => clearInterval(this._healthcheckInterval))
+          .then(() => clearTimeout(this._readyTimeout))
+          .then(resolve)
+          .catch(() => {});
+      }, SC_HEALTHCHECK_TIMEOUT);
+
+      this._readyTimeout = setTimeout(() => {
+        clearInterval(this._healthcheckInterval);
+        reject(new Error('Timeout waiting for healthcheck endpoint'));
+      }, SC_READY_TIMEOUT);
+    });
+  }
+
+  close() {
+    this.logger('Terminating Sauce Connect...');
+
+    return new Promise((resolve) => {
+      if (this.cp.exitCode !== null) {
+        return resolve();
+      }
+
+      const timeout = setTimeout(() => {
+        this.logger('Forcefully terminating Sauce Connect...');
+        killSilently(this.cp.pid, 'SIGKILL');
+        resolve();
+      }, SC_CLOSE_TIMEOUT);
+
+      this.cp.on('exit', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+
+      clearInterval(this._healthcheckInterval);
+      clearTimeout(this._readyTimeout);
+      killSilently(this.cp.pid, 'SIGINT');
+    });
+  }
+
+  async _callHealthcheckEndpoint(apiAddress) {
+    const response = await fetch(`${apiAddress}/readyz`, {
+      signal: AbortSignal.timeout(SC_HEALTHCHECK_TIMEOUT),
+    });
+    if (response.status !== 200) {
+      throw new Error(`response status code ${response.status} != 200`);
+    }
+  }
+
+  _parseApiAddress(value) {
+    const [host, port] = value.split(':');
+    return `http://${host || 'localhost'}:${port}`;
+  }
+}
+
+function killSilently(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (err) {
+    // ignore
+  }
+}