suthep 1.0.0

package/src/utils/config-loader.ts

@@ -0,0 +1,184 @@
+import fs from 'fs-extra'
+import yaml from 'js-yaml'
+import { dirname, resolve } from 'path'
+import type { DeployConfig } from '../types/config'
+import { loadAndApplyEnvFiles } from './env-loader'
+
+/**
+ * Substitute environment variables in a string
+ * Replaces ${VAR_NAME} or ${VAR_NAME:-default} patterns with values from envVars or process.env
+ *
+ * @param text The text containing variable references
+ * @param envVars Environment variables object
+ * @returns Text with variables substituted
+ */
+function substituteEnvVars(text: string, envVars: Record<string, string>): string {
+  // Match ${VAR_NAME} or ${VAR_NAME:-default} patterns
+  return text.replace(/\$\{([^}:]+)(?::-([^}]*))?\}/g, (match, varName, defaultValue) => {
+    // Check envVars first, then process.env
+    const value = envVars[varName] || process.env[varName]
+
+    if (value !== undefined && value !== null) {
+      return value
+    }
+
+    // Use default value if provided
+    if (defaultValue !== undefined) {
+      return defaultValue
+    }
+
+    // Return original match if not found and no default
+    return match
+  })
+}
+
+/**
+ * Recursively substitute environment variables in an object
+ */
+function substituteInObject(obj: any, envVars: Record<string, string>): any {
+  if (typeof obj === 'string') {
+    return substituteEnvVars(obj, envVars)
+  } else if (Array.isArray(obj)) {
+    return obj.map((item) => substituteInObject(item, envVars))
+  } else if (obj !== null && typeof obj === 'object') {
+    const result: any = {}
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = substituteInObject(value, envVars)
+    }
+    return result
+  }
+  return obj
+}
+
+/**
+ * Load and parse a YAML configuration file with environment variable substitution
+ * Variables in the format ${VAR_NAME} or ${VAR_NAME:-default} will be replaced
+ * with values from .env files or process.env
+ */
+export async function loadConfig(filePath: string): Promise<DeployConfig> {
+  try {
+    // Load .env files from the directory containing the config file
+    const configDir = dirname(resolve(filePath))
+    const envVars = await loadAndApplyEnvFiles(configDir)
+
+    // Read the YAML file content
+    const fileContent = await fs.readFile(filePath, 'utf8')
+
+    // Substitute environment variables in the YAML content before parsing
+    const substitutedContent = substituteEnvVars(fileContent, envVars)
+
+    // Parse the YAML
+    const config = yaml.load(substitutedContent) as DeployConfig
+
+    // Also substitute in the parsed object (in case YAML parsing didn't handle strings properly)
+    const finalConfig = substituteInObject(config, envVars) as DeployConfig
+
+    validateConfig(finalConfig)
+
+    return finalConfig
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`Failed to load configuration from ${filePath}: ${error.message}`)
+    }
+    throw error
+  }
+}
+
+/**
+ * Validate the configuration object
+ */
+function validateConfig(config: any): asserts config is DeployConfig {
+  if (!config.project || !config.project.name) {
+    throw new Error('Configuration must include project.name')
+  }
+
+  if (!config.services || !Array.isArray(config.services) || config.services.length === 0) {
+    throw new Error('Configuration must include at least one service')
+  }
+
+  // Track ports and container names to detect conflicts
+  const usedPorts = new Map<number, string[]>()
+  const usedContainers = new Map<string, string>()
+
+  for (const service of config.services) {
+    if (!service.name) {
+      throw new Error('Each service must have a name')
+    }
+    if (!service.port) {
+      throw new Error(`Service ${service.name} must have a port`)
+    }
+    if (!service.domains || !Array.isArray(service.domains) || service.domains.length === 0) {
+      throw new Error(`Service ${service.name} must have at least one domain`)
+    }
+
+    // Check for port conflicts
+    if (usedPorts.has(service.port)) {
+      const conflictingServices = usedPorts.get(service.port)!
+      throw new Error(
+        `Port conflict: Service "${service.name}" uses port ${
+          service.port
+        } which is already used by: ${conflictingServices.join(
+          ', '
+        )}. Each service must use a unique port.`
+      )
+    }
+    usedPorts.set(service.port, [service.name])
+
+    // Check for Docker container name conflicts
+    if (service.docker) {
+      const containerName = service.docker.container
+      if (usedContainers.has(containerName)) {
+        const conflictingService = usedContainers.get(containerName)!
+        throw new Error(
+          `Docker container name conflict: Service "${service.name}" uses container name "${containerName}" which is already used by service "${conflictingService}". Each Docker container must have a unique name.`
+        )
+      }
+      usedContainers.set(containerName, service.name)
+    }
+  }
+
+  // Check for duplicate service names
+  const serviceNames = new Set<string>()
+  for (const service of config.services) {
+    if (serviceNames.has(service.name)) {
+      throw new Error(
+        `Duplicate service name: "${service.name}" is used multiple times. Each service must have a unique name.`
+      )
+    }
+    serviceNames.add(service.name)
+  }
+
+  if (!config.nginx) {
+    config.nginx = {
+      configPath: '/etc/nginx/sites-available',
+      reloadCommand: 'sudo nginx -t && sudo systemctl reload nginx',
+    }
+  }
+
+  if (!config.certbot) {
+    config.certbot = {
+      email: '',
+      staging: false,
+    }
+  }
+
+  if (!config.deployment) {
+    config.deployment = {
+      strategy: 'rolling',
+      healthCheckTimeout: 30000,
+    }
+  }
+}
+
+/**
+ * Save configuration to a YAML file
+ */
+export async function saveConfig(filePath: string, config: DeployConfig): Promise<void> {
+  const yamlContent = yaml.dump(config, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+  })
+
+  await fs.writeFile(filePath, yamlContent, 'utf8')
+}

package/src/utils/deployment.ts

@@ -0,0 +1,157 @@
+import type { DeploymentConfig, ServiceConfig } from '../types/config'
+import type { ZeroDowntimeContainerInfo } from './docker'
+
+/**
+ * Perform a health check on a service endpoint
+ */
+export async function performHealthCheck(url: string, timeout: number = 30000): Promise<boolean> {
+  const startTime = Date.now()
+  const interval = 2000 // Check every 2 seconds
+
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(url, {
+        method: 'GET',
+        signal: AbortSignal.timeout(5000), // 5 second timeout per request
+      })
+
+      if (response.ok) {
+        return true
+      }
+    } catch (error) {
+      // Endpoint not ready yet, continue waiting
+    }
+
+    // Wait before next check
+    await new Promise((resolve) => setTimeout(resolve, interval))
+  }
+
+  return false
+}
+
+/**
+ * Deploy a service with zero-downtime strategy
+ */
+export async function deployService(
+  service: ServiceConfig,
+  deploymentConfig: DeploymentConfig,
+  tempInfo: ZeroDowntimeContainerInfo | null = null
+): Promise<void> {
+  if (deploymentConfig.strategy === 'rolling') {
+    await rollingDeploy(service, deploymentConfig, tempInfo)
+  } else if (deploymentConfig.strategy === 'blue-green') {
+    await blueGreenDeploy(service, deploymentConfig, tempInfo)
+  } else {
+    throw new Error(`Unknown deployment strategy: ${deploymentConfig.strategy}`)
+  }
+}
+
+/**
+ * Rolling deployment strategy
+ * For single instance, uses zero-downtime approach similar to blue-green
+ */
+async function rollingDeploy(
+  service: ServiceConfig,
+  deploymentConfig: DeploymentConfig,
+  tempInfo: ZeroDowntimeContainerInfo | null
+): Promise<void> {
+  // For rolling deployment with single instance:
+  // Similar to blue-green - use temporary container and port
+
+  if (!tempInfo || !tempInfo.oldContainerExists) {
+    // No existing container, just check health on the new container
+    if (service.healthCheck) {
+      const healthUrl = `http://localhost:${service.port}${service.healthCheck.path}`
+      const isHealthy = await performHealthCheck(healthUrl, deploymentConfig.healthCheckTimeout)
+
+      if (!isHealthy) {
+        throw new Error(`Service ${service.name} failed health check during rolling deployment`)
+      }
+    }
+  } else {
+    // Check health on temporary port
+    if (service.healthCheck) {
+      const healthUrl = `http://localhost:${tempInfo.tempPort}${service.healthCheck.path}`
+      const isHealthy = await performHealthCheck(healthUrl, deploymentConfig.healthCheckTimeout)
+
+      if (!isHealthy) {
+        throw new Error(
+          `Service ${service.name} failed health check on temporary container during rolling deployment`
+        )
+      }
+    }
+  }
+
+  // Add a small delay to ensure service is fully ready
+  await new Promise((resolve) => setTimeout(resolve, 2000))
+}
+
+/**
+ * Blue-green deployment strategy for single instance
+ * Uses temporary container and port for zero-downtime deployment
+ */
+async function blueGreenDeploy(
+  service: ServiceConfig,
+  deploymentConfig: DeploymentConfig,
+  tempInfo: ZeroDowntimeContainerInfo | null
+): Promise<void> {
+  // For blue-green deployment with single instance:
+  // 1. New container is already started on temporary port (handled in deploy command)
+  // 2. Run health checks on new container
+  // 3. Switch nginx to new port (handled in deploy command)
+  // 4. Stop old container and promote new one (handled in deploy command)
+
+  if (!tempInfo || !tempInfo.oldContainerExists) {
+    // No existing container, just check health on the new container
+    if (service.healthCheck) {
+      const healthUrl = `http://localhost:${service.port}${service.healthCheck.path}`
+      const isHealthy = await performHealthCheck(healthUrl, deploymentConfig.healthCheckTimeout)
+
+      if (!isHealthy) {
+        throw new Error(`Service ${service.name} failed health check during blue-green deployment`)
+      }
+    }
+  } else {
+    // Check health on temporary port
+    if (service.healthCheck) {
+      const healthUrl = `http://localhost:${tempInfo.tempPort}${service.healthCheck.path}`
+      const isHealthy = await performHealthCheck(healthUrl, deploymentConfig.healthCheckTimeout)
+
+      if (!isHealthy) {
+        throw new Error(
+          `Service ${service.name} failed health check on temporary container during blue-green deployment`
+        )
+      }
+    }
+  }
+}
+
+/**
+ * Wait for a service to become healthy
+ */
+export async function waitForService(
+  service: ServiceConfig,
+  timeout: number = 60000
+): Promise<boolean> {
+  if (!service.healthCheck) {
+    // No health check configured, assume service is ready after a short delay
+    await new Promise((resolve) => setTimeout(resolve, 5000))
+    return true
+  }
+
+  const healthUrl = `http://localhost:${service.port}${service.healthCheck.path}`
+  return await performHealthCheck(healthUrl, timeout)
+}
+
+/**
+ * Gracefully shutdown a service
+ */
+export async function gracefulShutdown(
+  _service: ServiceConfig,
+  timeout: number = 30000
+): Promise<void> {
+  // Send shutdown signal and wait for graceful termination
+  // This is a placeholder - actual implementation would depend on how services are managed
+
+  await new Promise((resolve) => setTimeout(resolve, Math.min(timeout, 5000)))
+}