feat: auto-restart policies, SSL monitoring, DNS propagation, dependency tracking, config drift detection

2026-06-10 14:43:46 -07:00
parent afcccf811e
commit 954be9e868
15 changed files with 3048 additions and 6 deletions
@@ -0,0 +1,164 @@
+/**
+ * Auto-Restart Policy Routes
+ *
+ * CRUD endpoints for per-container auto-restart policies.
+ * Also provides a dry-run test endpoint.
+ *
+ * @module routes/auto-restart
+ */
+
+const express = require('express');
+const { success } = require('../response-helpers');
+const { ValidationError, NotFoundError } = require('../errors');
+
+/**
+ * Auto-restart route factory
+ *
+ * @param {Object} deps - Explicit dependencies
+ * @param {Object}   deps.autoRestartManager - AutoRestartManager instance
+ * @param {Function} deps.asyncHandler - Async route handler wrapper
+ * @param {Function} deps.logError - Error logging function
+ * @returns {express.Router}
+ */
+module.exports = function ({ autoRestartManager, asyncHandler, logError }) {
+  const router = express.Router();
+
+  /**
+   * GET /auto-restart/policies
+   * List all configured auto-restart policies.
+   */
+  router.get('/policies', asyncHandler(async (_req, res) => {
+    const policies = autoRestartManager.listPolicies();
+    success(res, { policies });
+  }, 'auto-restart-list'));
+
+  /**
+   * GET /auto-restart/policies/:serviceId
+   * Get the restart policy for a single service.
+   */
+  router.get('/policies/:serviceId', asyncHandler(async (req, res) => {
+    const { serviceId } = req.params;
+
+    if (!serviceId || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,100}$/.test(serviceId)) {
+      throw new ValidationError('Invalid service ID format');
+    }
+
+    const policy = autoRestartManager.getPolicy(serviceId);
+    if (!policy) {
+      throw new NotFoundError(`Auto-restart policy for "${serviceId}"`);
+    }
+
+    success(res, { policy });
+  }, 'auto-restart-get'));
+
+  /**
+   * POST /auto-restart/policies/:serviceId
+   * Create or update a restart policy.
+   *
+   * Body: { enabled, maxRetries, retryIntervalMs, windowMinutes }
+   */
+  router.post('/policies/:serviceId', asyncHandler(async (req, res) => {
+    const { serviceId } = req.params;
+
+    if (!serviceId || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,100}$/.test(serviceId)) {
+      throw new ValidationError('Invalid service ID format');
+    }
+
+    const { enabled, maxRetries, retryIntervalMs, windowMinutes } = req.body;
+
+    // Validate inputs
+    if (enabled !== undefined && typeof enabled !== 'boolean') {
+      throw new ValidationError('enabled must be a boolean');
+    }
+    if (maxRetries !== undefined) {
+      if (!Number.isInteger(maxRetries) || maxRetries < 0 || maxRetries > 100) {
+        throw new ValidationError('maxRetries must be an integer between 0 and 100');
+      }
+    }
+    if (retryIntervalMs !== undefined) {
+      if (!Number.isInteger(retryIntervalMs) || retryIntervalMs < 0 || retryIntervalMs > 3600000) {
+        throw new ValidationError('retryIntervalMs must be an integer between 0 and 3600000');
+      }
+    }
+    if (windowMinutes !== undefined) {
+      if (!Number.isInteger(windowMinutes) || windowMinutes < 0 || windowMinutes > 1440) {
+        throw new ValidationError('windowMinutes must be an integer between 0 and 1440');
+      }
+    }
+
+    const policy = await autoRestartManager.setPolicy(serviceId, {
+      ...(enabled !== undefined && { enabled }),
+      ...(maxRetries !== undefined && { maxRetries }),
+      ...(retryIntervalMs !== undefined && { retryIntervalMs }),
+      ...(windowMinutes !== undefined && { windowMinutes }),
+    });
+
+    success(res, { policy, message: `Policy ${serviceId} saved` });
+  }, 'auto-restart-set'));
+
+  /**
+   * DELETE /auto-restart/policies/:serviceId
+   * Remove a restart policy.
+   */
+  router.delete('/policies/:serviceId', asyncHandler(async (req, res) => {
+    const { serviceId } = req.params;
+
+    if (!serviceId || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,100}$/.test(serviceId)) {
+      throw new ValidationError('Invalid service ID format');
+    }
+
+    const removed = await autoRestartManager.removePolicy(serviceId);
+    if (!removed) {
+      throw new NotFoundError(`Auto-restart policy for "${serviceId}"`);
+    }
+
+    success(res, { message: `Policy for "${serviceId}" removed` });
+  }, 'auto-restart-delete'));
+
+  /**
+   * POST /auto-restart/policies/:serviceId/test
+   * Dry-run: simulate a restart attempt without actually restarting.
+   * Returns what *would* happen given the current policy state.
+   */
+  router.post('/policies/:serviceId/test', asyncHandler(async (req, res) => {
+    const { serviceId } = req.params;
+
+    if (!serviceId || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,100}$/.test(serviceId)) {
+      throw new ValidationError('Invalid service ID format');
+    }
+
+    const policy = autoRestartManager.getPolicy(serviceId);
+    if (!policy) {
+      throw new NotFoundError(`Auto-restart policy for "${serviceId}"`);
+    }
+
+    const now = Date.now();
+    const inCooldown = policy.cooldownUntil && now < policy.cooldownUntil;
+    const wouldRetry = !inCooldown && policy.currentRetries < policy.maxRetries;
+    const nextAttempt = policy.currentRetries + 1;
+
+    success(res, {
+      dryRun: true,
+      serviceId,
+      policy: {
+        enabled: policy.enabled,
+        currentRetries: policy.currentRetries,
+        maxRetries: policy.maxRetries,
+        cooldownUntil: policy.cooldownUntil,
+        inCooldown,
+      },
+      wouldRestart: policy.enabled && wouldRetry,
+      wouldMaxOut: !wouldRetry && !inCooldown,
+      nextAttempt: wouldRetry ? nextAttempt : null,
+      message: !policy.enabled
+        ? 'Policy is disabled — no restart would occur'
+        : inCooldown
+          ? `In cooldown until ${new Date(policy.cooldownUntil).toISOString()} — would skip`
+          : wouldRetry
+            ? `Would attempt restart ${nextAttempt}/${policy.maxRetries}`
+            : `Max retries (${policy.maxRetries}) already reached — would enter cooldown`,
+    });
+  }, 'auto-restart-test'));
+
+  return router;
+};