go-dev 0.4.2 → 0.6.0

package/src/services/docker.js

@@ -1,198 +1,195 @@
-const { BaseService } = require('./base');
-
-class DockerService extends BaseService {
-  /** @type {Map<string, string[]>} */
-  static _servicesToStop = new Map();
-
-  static async cleanup() {
-    if (!DockerService._processManager) {
-      console.warn('[DockerService] ProcessManager not initialized, skipping static cleanup.');
-      return;
-    }
-
-    if (DockerService._servicesToStop.size > 0) {
-      console.log('[DockerService] Stopping all docker services from used compose files...');
-      for (const [composeFile, services] of this._servicesToStop.entries()) {
-        try {
-          console.log(`[DockerService] Stopping services ${services.map(service => `'${service}'`).join(', ')} of '${composeFile}'`);
-          DockerService._processManager.runSync(
-            'docker',
-            ['compose', '-f', composeFile, 'stop', ...services],
-            { stdio: 'inherit' },
-          );
-        } catch (error) {
-          console.error(
-            `[DockerService] Failed to stop services of '${composeFile}': ${error.message}`,
-          );
-        }
-      }
-      DockerService._servicesToStop.clear();
-    } else {
-      console.log('[DockerService] No docker services were started by orchestrator, skipping global stop.');
-    }
-  }
-
-  constructor(name, mode, config) {
-    super(name, mode, config);
-    this.dockerServiceName = config.service;
-    this.dockerComposeFile = config.composeFile;
-    this.containerName = null;
-  }
-
-  async start() {
-    console.log(`[${this.name}:${this.mode}] Starting docker service '${this.dockerServiceName}' (using ${this.dockerComposeFile})...`);
-
-    let status = this._getContainerStatus();
-    if (status === 'running') {
-      console.log(
-        `[${this.name}:${this.mode}] Docker container for '${this.dockerServiceName}' is already running.`,
-      );
-    } else {
-      console.log(`[${this.name}:${this.mode}] Bringing up docker service '${this.dockerServiceName}'...`);
-      try {
-        const servicesBeforeStart = this._getCurrentlyRunningServices();
-        await DockerService._processManager.runInherited(
-          'docker',
-          ['compose', '-f', this.dockerComposeFile, 'up', this.dockerServiceName, '-d'],
-        );
-        const servicesAfterStart = this._getCurrentlyRunningServices();
-        let servicesOfComposeFile = DockerService._servicesToStop.get(this.dockerComposeFile);
-        if (servicesOfComposeFile == null) {
-          servicesOfComposeFile = [];
-        }
-        const newServices = servicesAfterStart.filter(service => {
-          return !(
-            servicesBeforeStart.includes(service) ||
-            servicesOfComposeFile.includes(service)
-          );
-        });
-        DockerService._servicesToStop.set(
-          this.dockerComposeFile,
-          servicesOfComposeFile.concat(newServices)
-        );
-        console.log(`[${this.name}:${this.mode}] Docker service '${this.dockerServiceName}' brought up.`);
-        if (newServices.length > 1) {
-          console.log(`[${this.name}:${this.mode}] Dependency service${newServices.length > 2 ? 's' : ''} for '${this.dockerServiceName}': ${newServices.filter(service => service.name !== this.dockerServiceName).join(', ')}`);
-        }
-      } catch (error) {
-        throw new Error(
-          `[${this.name}:${this.mode}] Failed to bring up docker service '${this.dockerServiceName}': ${error.message}`,
-        );
-      }
-    }
-
-    if (this.config.healthCheck) {
-      console.log(`[${this.name}:${this.mode}] Checking healthiness for '${this.dockerServiceName}'...`);
-      try {
-        await this._checkServiceHealthiness();
-        console.log(`[${this.name}:${this.mode}] Docker service '${this.dockerServiceName}' is healthy.`);
-      } catch (error) {
-        throw new Error(
-          `[${this.name}:${this.mode}] Health check failed for '${this.dockerServiceName}': ${error.message}`,
-        );
-      }
-    } else {
-      console.log(`[${this.name}:${this.mode}] Skipping health check for '${this.dockerServiceName}'.`);
-    }
-  }
-
-  async stop() {
-    console.log(`[${this.name}:${this.mode}] Relying on orchestrator's static docker compose stop for '${this.dockerServiceName}'.`);
-    this.containerName = null;
-  }
-
-  async checkHealth() {
-    return await this._checkServiceHealthiness();
-  }
-
-  _getCurrentlyRunningServices() {
-    try {
-      const services = DockerService._processManager.runSync(
-        'docker',
-        ['compose', '-f', this.dockerComposeFile, 'ps', '--services'],
-      );
-      return (services
-        .split('\n')
-        .map(serviceName => serviceName.trim())
-        .filter(serviceName => serviceName !== '')
-      );
-    } catch (error) {
-      // console.warn(...);
-    }
-    return null;
-  }
-
-  _getContainerName() {
-    if (this.containerName) {
-      return this.containerName;
-    }
-    try {
-      const name = DockerService._processManager.runSync(
-        'docker',
-        ['compose', '-f', this.dockerComposeFile, 'ps', '-a', '-q', this.dockerServiceName],
-      );
-      if (name) {
-        this.containerName = name;
-        return name;
-      }
-    } catch (error) {
-      // console.warn(...);
-    }
-    return null;
-  }
-
-  _getContainerStatus() {
-    const containerName = this._getContainerName();
-    if (!containerName) {
-      return null;
-    }
-    try {
-      return DockerService._processManager.runSync(
-        'docker',
-        ['container', 'inspect', '-f', '{{.State.Status}}', containerName],
-      );
-    } catch (error) {
-      // console.warn(...);
-      return null;
-    }
-  }
-
-  async _checkServiceHealthiness(maxAttempts = 30, delayMs = 1000) {
-    const containerName = this._getContainerName();
-    if (!containerName) {
-      throw new Error(`[${this.name}:${this.mode}] Cannot check health: Container for '${this.dockerServiceName}' not found.`);
-    }
-
-    console.log(`[${this.name}:${this.mode}] Checking healthiness for '${containerName}'`);
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      if (attempt > 1) {
-        await new Promise(resolve => setTimeout(resolve, delayMs));
-      }
-
-      try {
-        const healthStatus = DockerService._processManager.runSync(
-          'docker',
-          ['container', 'inspect', '-f', '{{.State.Health.Status}}', containerName],
-          { stdio: 'pipe' }
-        );
-
-        if (healthStatus === 'healthy' || healthStatus === 'none') {
-          console.log(`[${this.name}:${this.mode}] Container '${containerName}' healthy!`);
-          return true;
-        }
-
-        if (healthStatus === 'starting' || healthStatus === 'unhealthy') {
-          continue;
-        }
-
-        throw new Error(`[${this.name}:${this.mode}] Container '${containerName}' is in unexpected health state: ${healthStatus}`);
-      } catch (error) {
-        throw new Error(`[${this.name}:${this.mode}] Failed to check health for '${containerName}': ${error.message}`);
-      }
-    }
-
-    throw new Error(`[${this.name}:${this.mode}] Service '${this.dockerServiceName}' wasn't healthy in time after ${maxAttempts} attempts.`);
-  }
-}
-
+const log = require('../logger');
+const { BaseService } = require('./base');
+
+class DockerService extends BaseService {
+  /** @type {Map<string, string[]>} */
+  static _servicesToStop = new Map();
+
+  static async cleanup() {
+    if (!DockerService._processManager) {
+      log.warn('[DockerService] ProcessManager not initialized, skipping static cleanup.');
+      return;
+    }
+
+    if (DockerService._servicesToStop.size > 0) {
+      log.info('');
+    }
+
+    for (const [composeFile, services] of this._servicesToStop.entries()) {
+      try {
+        DockerService._processManager.runSync(
+          'docker',
+          ['compose', '-f', composeFile, 'stop', ...services],
+          { stdio: 'inherit' },
+        );
+      } catch (error) {
+        log.error(`Failed to stop docker services of '${composeFile}': ${error.message}`);
+      }
+    }
+    DockerService._servicesToStop.clear();
+  }
+
+  constructor(name, mode, config) {
+    super(name, mode, config);
+    this.dockerServiceName = config.service;
+    this.dockerComposeFile = config.composeFile;
+    this.containerName = null;
+  }
+
+  async start() {
+    log.info(`[${this.coloredId}] Starting docker service '${this.dockerServiceName}' (using ${this.dockerComposeFile})...`);
+
+    let status = this._getContainerStatus();
+    if (status === 'running') {
+      log.info(
+        `[${this.coloredId}] Docker container for '${this.dockerServiceName}' is already running.`,
+      );
+    } else {
+      log.info(`[${this.coloredId}] Bringing up docker service '${this.dockerServiceName}'...`);
+      try {
+        const servicesBeforeStart = this._getCurrentlyRunningServices();
+        await DockerService._processManager.runInherited(
+          'docker',
+          ['compose', '-f', this.dockerComposeFile, 'up', this.dockerServiceName, '-d'],
+        );
+        const servicesAfterStart = this._getCurrentlyRunningServices();
+        let servicesOfComposeFile = DockerService._servicesToStop.get(this.dockerComposeFile);
+        if (servicesOfComposeFile == null) {
+          servicesOfComposeFile = [];
+        }
+        const newServices = servicesAfterStart.filter(service => {
+          return !(
+            servicesBeforeStart.includes(service) ||
+            servicesOfComposeFile.includes(service)
+          );
+        });
+        DockerService._servicesToStop.set(
+          this.dockerComposeFile,
+          servicesOfComposeFile.concat(newServices)
+        );
+        log.info(`[${this.coloredId}] Docker service '${this.dockerServiceName}' brought up.`);
+        if (newServices.length > 1) {
+          log.info(`[${this.coloredId}] Dependency service${newServices.length > 2 ? 's' : ''} for '${this.dockerServiceName}': ${newServices.filter(service => service.name !== this.dockerServiceName).join(', ')}`);
+        }
+      } catch (error) {
+        throw new Error(
+          `[${this.coloredId}] Failed to bring up docker service '${this.dockerServiceName}': ${error.message}`,
+        );
+      }
+    }
+
+    if (this.config.healthCheck) {
+      log.info(`[${this.coloredId}] Checking healthiness for '${this.dockerServiceName}'...`);
+      try {
+        await this._checkServiceHealthiness();
+        log.info(`[${this.coloredId}] Docker service '${this.dockerServiceName}' is healthy.`);
+      } catch (error) {
+        throw new Error(
+          `[${this.coloredId}] Health check failed for '${this.dockerServiceName}': ${error.message}`,
+        );
+      }
+    } else {
+      log.info(`[${this.coloredId}] Skipping health check for '${this.dockerServiceName}'.`);
+    }
+  }
+
+  async stop() {
+    log.debug(`[${this.coloredId}] Relying on orchestrator's static docker compose stop for '${this.dockerServiceName}'.`);
+    this.containerName = null;
+  }
+
+  async checkHealth() {
+    return await this._checkServiceHealthiness();
+  }
+
+  _getCurrentlyRunningServices() {
+    try {
+      const services = DockerService._processManager.runSync(
+        'docker',
+        ['compose', '-f', this.dockerComposeFile, 'ps', '--services'],
+      );
+      return (services
+        .split('\n')
+        .map(serviceName => serviceName.trim())
+        .filter(serviceName => serviceName !== '')
+      );
+    } catch (error) {
+      // console.warn(...);
+    }
+    return null;
+  }
+
+  _getContainerName() {
+    if (this.containerName) {
+      return this.containerName;
+    }
+    try {
+      const name = DockerService._processManager.runSync(
+        'docker',
+        ['compose', '-f', this.dockerComposeFile, 'ps', '-a', '-q', this.dockerServiceName],
+      );
+      if (name) {
+        this.containerName = name;
+        return name;
+      }
+    } catch (error) {
+      // console.warn(...);
+    }
+    return null;
+  }
+
+  _getContainerStatus() {
+    const containerName = this._getContainerName();
+    if (!containerName) {
+      return null;
+    }
+    try {
+      return DockerService._processManager.runSync(
+        'docker',
+        ['container', 'inspect', '-f', '{{.State.Status}}', containerName],
+      );
+    } catch (error) {
+      // console.warn(...);
+      return null;
+    }
+  }
+
+  async _checkServiceHealthiness(maxAttempts = 30, delayMs = 1000) {
+    const containerName = this._getContainerName();
+    if (!containerName) {
+      throw new Error(`[${this.coloredId}] Cannot check health: Container for '${this.dockerServiceName}' not found.`);
+    }
+
+    log.info(`[${this.coloredId}] Checking healthiness for '${containerName}'`);
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      if (attempt > 1) {
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+      }
+
+      try {
+        const healthStatus = DockerService._processManager.runSync(
+          'docker',
+          ['container', 'inspect', '-f', '{{.State.Health.Status}}', containerName],
+          { stdio: 'pipe' }
+        );
+
+        if (healthStatus === 'healthy' || healthStatus === 'none') {
+          log.info(`[${this.coloredId}] Container '${containerName}' healthy!`);
+          return true;
+        }
+
+        if (healthStatus === 'starting' || healthStatus === 'unhealthy') {
+          continue;
+        }
+
+        throw new Error(`[${this.coloredId}] Container '${containerName}' is in unexpected health state: ${healthStatus}`);
+      } catch (error) {
+        throw new Error(`[${this.coloredId}] Failed to check health for '${containerName}': ${error.message}`);
+      }
+    }
+
+    throw new Error(`[${this.coloredId}] Service '${this.dockerServiceName}' wasn't healthy in time after ${maxAttempts} attempts.`);
+  }
+}
+
 module.exports = { DockerService };

package/src/services/ready-check.js

@@ -0,0 +1,134 @@
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+const log = require('../logger');
+
+const MAX_BUFFER = 16 * 1024;
+
+/**
+ * Resolves when one of the managed processes prints a line matching `pattern`.
+ * Attaches an extra listener on top of the existing prefixing one, so it does
+ * not interfere with normal output.
+ */
+function logMatchCheck(processes, pattern, timeoutMs) {
+  const regex = new RegExp(pattern);
+  let cleanup = () => {};
+  const promise = new Promise((resolve, reject) => {
+    let buffer = '';
+    const listeners = [];
+    const onData = (data) => {
+      buffer = (buffer + data.toString()).slice(-MAX_BUFFER);
+      if (regex.test(buffer)) {
+        resolve();
+      }
+    };
+    for (const proc of processes) {
+      for (const stream of [proc.stdout, proc.stderr]) {
+        if (!stream) {
+          continue;
+        }
+        stream.on('data', onData);
+        listeners.push(stream);
+      }
+    }
+    const timer = setTimeout(() => {
+      reject(new Error(`Timed out after ${timeoutMs}ms waiting for log /${pattern}/`));
+    }, timeoutMs);
+    cleanup = () => {
+      clearTimeout(timer);
+      for (const stream of listeners) {
+        stream.off('data', onData);
+      }
+    };
+  });
+  return { promise: promise.finally(() => cleanup()), cancel: () => cleanup() };
+}
+
+/** Resolves once `filePath` exists on disk, polling until the timeout. */
+function fileCheck(filePath, timeoutMs, pollIntervalMs) {
+  const resolved = path.resolve(filePath);
+  let cancelled = false;
+  const promise = (async () => {
+    const deadline = Date.now() + timeoutMs;
+    while (!cancelled) {
+      if (fs.existsSync(resolved)) {
+        return;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out after ${timeoutMs}ms waiting for file '${resolved}'`);
+      }
+      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+  })();
+  return { promise, cancel: () => { cancelled = true; } };
+}
+
+function tryConnect(host, port) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host, port });
+    const done = (ok) => {
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.once('connect', () => done(true));
+    socket.once('error', () => done(false));
+    socket.setTimeout(1000, () => done(false));
+  });
+}
+
+/** Resolves once a TCP connection to `host:port` succeeds, polling until the timeout. */
+function portCheck(host, port, timeoutMs, pollIntervalMs) {
+  let cancelled = false;
+  const promise = (async () => {
+    const deadline = Date.now() + timeoutMs;
+    while (!cancelled) {
+      if (await tryConnect(host, port)) {
+        return;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out after ${timeoutMs}ms waiting for ${host}:${port}`);
+      }
+      await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+    }
+  })();
+  return { promise, cancel: () => { cancelled = true; } };
+}
+
+/**
+ * Blocks until the given `readyWhen` conditions are all satisfied for the
+ * provided managed processes. Multiple conditions are combined with AND.
+ * @param {import('child_process').ChildProcess[]} processes
+ * @param {object} readyWhen - Validated `readyWhen` config (with defaults applied).
+ * @param {string} coloredId - The service's colored tag, for logging.
+ */
+async function waitForReady(processes, readyWhen, coloredId) {
+  const { logMatch, file, port, host, timeoutMs, pollIntervalMs } = readyWhen;
+
+  const checks = [];
+  const labels = [];
+  if (logMatch != null) {
+    checks.push(logMatchCheck(processes, logMatch, timeoutMs));
+    labels.push(`log /${logMatch}/`);
+  }
+  if (file != null) {
+    checks.push(fileCheck(file, timeoutMs, pollIntervalMs));
+    labels.push(`file '${file}'`);
+  }
+  if (port != null) {
+    checks.push(portCheck(host, port, timeoutMs, pollIntervalMs));
+    labels.push(`${host}:${port}`);
+  }
+
+  log.info(`[${coloredId}] Waiting until ready (${labels.join(' AND ')})...`);
+  try {
+    await Promise.all(checks.map(check => check.promise));
+    log.info(`[${coloredId}] Service is ready.`);
+  } finally {
+    // Stop any still-pending checks so they don't reject after we're done.
+    for (const check of checks) {
+      check.cancel();
+    }
+  }
+}
+
+module.exports = { waitForReady };