gjallarhorn 0.1.0.alpha → 0.1.0

data/lib/gjallarhorn/deployment/basic.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative "strategy"
+
+module Gjallarhorn
+  module Deployment
+    # Basic deployment strategy
+    #
+    # Implements a simple deployment strategy that stops old containers
+    # and starts new ones without zero-downtime guarantees. This is the
+    # fallback strategy when zero-downtime features are not needed.
+    #
+    # @since 0.1.0
+    class Basic < Strategy
+      # Deploy services using basic strategy
+      #
+      # @param image [String] Container image to deploy
+      # @param environment [String] Target environment
+      # @param services [Array<Hash>] Services to deploy
+      # @return [void]
+      def deploy(image:, environment:, services:)
+        @logger.info "Starting basic deployment of #{image} to #{environment}"
+
+        services.each do |service|
+          @logger.info "Deploying service: #{service[:name]}"
+          deploy_service_basic(service, image, environment)
+        end
+
+        @logger.info "Basic deployment completed successfully"
+      end
+
+      # Check if strategy supports zero-downtime deployments
+      #
+      # @return [Boolean] Always false for basic strategy
+      def zero_downtime?
+        false
+      end
+
+      private
+
+      # Deploy a single service using basic strategy
+      #
+      # @param service [Hash] Service configuration
+      # @param image [String] Container image to deploy
+      # @param environment [String] Target environment
+      # @return [void]
+      def deploy_service_basic(service, image, environment)
+        service_name = service[:name]
+
+        # Step 1: Stop existing containers
+        @logger.info "Stopping existing containers for #{service_name}..."
+        stop_existing_containers(service_name)
+
+        # Step 2: Start new container
+        new_container = start_new_container(service, image, environment)
+        @logger.info "Started new container: #{new_container[:name]} (#{new_container[:id]})"
+
+        # Step 3: Wait for container to be running
+        wait_for_container_running(new_container)
+
+        # Step 4: Optional health check
+        if service[:healthcheck]
+          @logger.info "Waiting for health check to pass..."
+          wait_for_container_health(new_container, service[:healthcheck])
+        end
+
+        @logger.info "Service #{service_name} deployed successfully"
+      end
+
+      # Stop all existing containers for a service
+      #
+      # @param service_name [String] Service name
+      # @return [void]
+      def stop_existing_containers(service_name)
+        current_containers = @adapter.get_running_containers(service_name)
+
+        current_containers.each do |container|
+          @logger.info "Stopping container: #{container[:name]} (#{container[:id]})"
+          @adapter.stop_container(container[:id], graceful: true)
+          @adapter.remove_container(container[:id])
+        end
+      rescue StandardError => e
+        @logger.warn "Failed to stop some existing containers: #{e.message}"
+        # Continue with deployment even if cleanup fails
+      end
+
+      # Start a new container for the service
+      #
+      # @param service [Hash] Service configuration
+      # @param image [String] Container image
+      # @param environment [String] Target environment
+      # @return [Hash] New container information
+      def start_new_container(service, image, environment)
+        container_name = generate_container_name(service[:name])
+
+        container_config = {
+          name: container_name,
+          image: image,
+          ports: service[:ports] || [],
+          env: build_environment_variables(service, environment),
+          volumes: service[:volumes] || [],
+          command: service[:cmd],
+          labels: build_container_labels(service, environment),
+          restart_policy: service[:restart_policy] || "unless-stopped"
+        }
+
+        @adapter.start_container(container_config)
+      end
+
+      # Build environment variables for container
+      #
+      # @param service [Hash] Service configuration
+      # @param environment [String] Target environment
+      # @return [Hash] Environment variables
+      def build_environment_variables(service, environment)
+        env_vars = {
+          "GJALLARHORN_SERVICE" => service[:name],
+          "GJALLARHORN_ENVIRONMENT" => environment,
+          "GJALLARHORN_DEPLOYED_AT" => Time.now.utc.iso8601
+        }
+
+        # Add service-specific environment variables
+        env_vars.merge!(service[:env]) if service[:env]
+
+        env_vars
+      end
+
+      # Build container labels for identification and management
+      #
+      # @param service [Hash] Service configuration
+      # @param environment [String] Target environment
+      # @return [Hash] Container labels
+      def build_container_labels(service, environment)
+        {
+          "gjallarhorn.service" => service[:name],
+          "gjallarhorn.environment" => environment,
+          "gjallarhorn.role" => service[:role] || "web",
+          "gjallarhorn.deployed_at" => Time.now.utc.iso8601,
+          "gjallarhorn.strategy" => "basic"
+        }
+      end
+
+      # Wait for container to be in running state
+      #
+      # @param container [Hash] Container information
+      # @param timeout [Integer] Timeout in seconds
+      # @return [Boolean] True when container is running
+      def wait_for_container_running(container, timeout = 60)
+        start_time = Time.now
+
+        loop do
+          status = @adapter.get_container_status(container[:id])
+
+          if status == "running"
+            @logger.info "Container #{container[:name]} is running"
+            return true
+          end
+
+          elapsed = Time.now - start_time
+          if elapsed >= timeout
+            raise DeploymentError,
+                  "Container #{container[:name]} failed to start within #{timeout}s (status: #{status})"
+          end
+
+          @logger.debug "Container #{container[:name]} status: #{status}, waiting..."
+          sleep 2
+        end
+      end
+    end
+  end
+end

data/lib/gjallarhorn/deployment/legacy.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "strategy"
+
+module Gjallarhorn
+  module Deployment
+    # Legacy deployment strategy
+    #
+    # Maintains backward compatibility with the original deployment interface
+    # by calling the adapter's deploy method directly. This is used for
+    # testing and for adapters that haven't been updated to the new
+    # container management interface.
+    #
+    # @since 0.1.0
+    class Legacy < Strategy
+      # Deploy services using legacy adapter interface
+      #
+      # @param image [String] Container image to deploy
+      # @param environment [String] Target environment
+      # @param services [Array<Hash>] Services to deploy
+      # @return [void]
+      def deploy(image:, environment:, services:)
+        @logger.info "Using legacy deployment interface"
+
+        @adapter.deploy(
+          image: image,
+          environment: environment,
+          services: services
+        )
+      end
+
+      # Check if strategy supports zero-downtime deployments
+      #
+      # @return [Boolean] Always false for legacy strategy
+      def zero_downtime?
+        false
+      end
+    end
+  end
+end

data/lib/gjallarhorn/deployment/strategy.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Gjallarhorn
+  module Deployment
+    # Base class for deployment strategies
+    #
+    # Defines the interface that all deployment strategies must implement.
+    # Each strategy handles the specifics of how containers are deployed,
+    # updated, and managed during the deployment process.
+    #
+    # @abstract Subclass and override deployment methods
+    # @since 0.1.0
+    class Strategy
+      attr_reader :adapter, :proxy_manager, :logger
+
+      # Initialize a deployment strategy
+      #
+      # @param adapter [Adapter::Base] The cloud adapter to use
+      # @param proxy_manager [Proxy::Manager] The proxy manager for traffic switching
+      # @param logger [Logger] Logger instance
+      def initialize(adapter, proxy_manager, logger = nil)
+        @adapter = adapter
+        @proxy_manager = proxy_manager
+        @logger = logger || Logger.new($stdout)
+      end
+
+      # Deploy services using this strategy
+      #
+      # @param image [String] Container image to deploy
+      # @param environment [String] Target environment
+      # @param services [Array<Hash>] Services to deploy
+      # @abstract Subclasses must implement this method
+      # @raise [NotImplementedError] If not implemented by subclass
+      # @return [void]
+      def deploy(image:, environment:, services:)
+        raise NotImplementedError, "Subclasses must implement deploy method"
+      end
+
+      # Check if strategy supports zero-downtime deployments
+      #
+      # @return [Boolean] True if strategy supports zero-downtime
+      def zero_downtime?
+        false
+      end
+
+      # Get strategy name
+      #
+      # @return [String] Strategy name
+      def name
+        self.class.name.split("::").last.downcase
+      end
+
+      protected
+
+      # Wait for container to become healthy
+      #
+      # @param container [Hash] Container information
+      # @param healthcheck [Hash] Health check configuration
+      # @param timeout [Integer] Timeout in seconds
+      # @raise [HealthCheckTimeoutError] If health check times out
+      # @return [Boolean] True when container is healthy
+      def wait_for_container_health(container, healthcheck, timeout = 300)
+        max_attempts = healthcheck[:max_attempts] || 30
+        interval = healthcheck[:interval] || 3
+        start_time = Time.now
+
+        attempts = 0
+
+        loop do
+          if container_healthy?(container, healthcheck)
+            @logger.info "Container #{container[:name]} passed health check after #{attempts} attempts"
+            return true
+          end
+
+          attempts += 1
+          elapsed = Time.now - start_time
+
+          if attempts >= max_attempts || elapsed >= timeout
+            raise HealthCheckTimeoutError,
+                  "Container #{container[:name]} failed health check after #{attempts} attempts (#{elapsed.round(1)}s)"
+          end
+
+          @logger.debug "Health check attempt #{attempts}/#{max_attempts} failed, retrying in #{interval}s..."
+          sleep interval
+        end
+      end
+
+      # Check if container is healthy
+      #
+      # @param container [Hash] Container information
+      # @param healthcheck [Hash] Health check configuration
+      # @return [Boolean] True if container is healthy
+      def container_healthy?(container, healthcheck)
+        case healthcheck[:type]
+        when "http", nil
+          http_health_check(container, healthcheck)
+        when "command"
+          command_health_check(container, healthcheck)
+        when "docker"
+          docker_health_check(container)
+        else
+          @logger.warn "Unknown health check type: #{healthcheck[:type]}, defaulting to HTTP"
+          http_health_check(container, healthcheck)
+        end
+      end
+
+      # Perform HTTP health check
+      #
+      # @param container [Hash] Container information
+      # @param healthcheck [Hash] Health check configuration
+      # @return [Boolean] True if HTTP check passes
+      def http_health_check(container, healthcheck)
+        require "net/http"
+        require "uri"
+
+        path = healthcheck[:path] || "/health"
+        port = healthcheck[:port] || 3000
+        expected_status = healthcheck[:expected_status] || [200, 204]
+        expected_status = [expected_status] unless expected_status.is_a?(Array)
+
+        # Try to get container IP or use localhost if running locally
+        host = container[:ip] || container[:host] || "localhost"
+        url = "http://#{host}:#{port}#{path}"
+
+        begin
+          uri = URI(url)
+          response = Net::HTTP.get_response(uri)
+          status_ok = expected_status.include?(response.code.to_i)
+
+          @logger.debug "Health check #{url} returned #{response.code}" if status_ok
+          status_ok
+        rescue StandardError => e
+          @logger.debug "Health check failed: #{e.message}"
+          false
+        end
+      end
+
+      # Perform command-based health check
+      #
+      # @param container [Hash] Container information
+      # @param healthcheck [Hash] Health check configuration
+      # @return [Boolean] True if command succeeds
+      def command_health_check(container, healthcheck)
+        command = healthcheck[:command] || healthcheck[:cmd]
+        return false unless command
+
+        begin
+          @adapter.execute_in_container(container[:id], command)
+          true
+        rescue StandardError => e
+          @logger.debug "Command health check failed: #{e.message}"
+          false
+        end
+      end
+
+      # Perform Docker health check
+      #
+      # @param container [Hash] Container information
+      # @return [Boolean] True if Docker reports container as healthy
+      def docker_health_check(container)
+        @adapter.get_container_health(container[:id])
+      rescue StandardError => e
+        @logger.debug "Docker health check failed: #{e.message}"
+        false
+      end
+
+      # Generate unique container name with timestamp
+      #
+      # @param service_name [String] Base service name
+      # @return [String] Unique container name
+      def generate_container_name(service_name)
+        timestamp = Time.now.strftime("%Y%m%d-%H%M%S")
+        "#{service_name}-#{timestamp}-#{SecureRandom.hex(4)}"
+      end
+
+      # Generate version suffix for tracking
+      #
+      # @return [String] Version suffix
+      def generate_version_suffix
+        Time.now.strftime("%Y%m%d-%H%M%S")
+      end
+    end
+
+    # Raised when health checks timeout
+    class HealthCheckTimeoutError < Error; end
+  end
+end

data/lib/gjallarhorn/deployment/zero_downtime.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require_relative "strategy"
+
+module Gjallarhorn
+  module Deployment
+    # Zero-downtime deployment strategy
+    #
+    # Implements zero-downtime deployments by:
+    # 1. Starting new containers alongside existing ones
+    # 2. Waiting for new containers to pass health checks
+    # 3. Switching proxy traffic to new containers
+    # 4. Gracefully stopping old containers
+    #
+    # This ensures continuous service availability during deployments.
+    #
+    # @since 0.1.0
+    class ZeroDowntime < Strategy
+      # Deploy services with zero downtime
+      #
+      # @param image [String] Container image to deploy
+      # @param environment [String] Target environment
+      # @param services [Array<Hash>] Services to deploy
+      # @return [void]
+      def deploy(image:, environment:, services:)
+        @logger.info "Starting zero-downtime deployment of #{image} to #{environment}"
+
+        # Set the environment on the adapter so it knows which environment we're deploying to
+        @adapter.set_environment(environment) if @adapter.respond_to?(:set_environment)
+
+        deployment_results = []
+
+        services.each do |service|
+          # Convert string keys to symbols for consistency
+          service = service.transform_keys(&:to_sym) if service.is_a?(Hash)
+          @logger.info "Deploying service: #{service[:name]}"
+          result = deploy_service_zero_downtime(service, image, environment)
+          deployment_results << result
+        end
+
+        @logger.info "Zero-downtime deployment completed successfully"
+        deployment_results
+      end
+
+      # Check if strategy supports zero-downtime deployments
+      #
+      # @return [Boolean] Always true for this strategy
+      def zero_downtime?
+        true
+      end
+
+      private
+
+      # Deploy a single service with zero downtime
+      #
+      # @param service [Hash] Service configuration
+      # @param image [String] Container image to deploy
+      # @param environment [String] Target environment
+      # @return [Hash] Deployment result
+      def deploy_service_zero_downtime(service, image, environment)
+        # Ensure service hash uses symbol keys
+        service = service.transform_keys(&:to_sym) if service.is_a?(Hash)
+        service_name = service[:name]
+
+        # Step 1: Get current running containers
+        current_containers = get_current_containers(service_name)
+        @logger.info "Found #{current_containers.length} existing containers for #{service_name}"
+
+        # Step 2: Start new container
+        new_container = start_new_container(service, image, environment)
+        @logger.info "Started new container: #{new_container[:name]} (#{new_container[:id]})"
+
+        # Step 3: Wait for new container to be healthy
+        if service[:healthcheck]
+          @logger.info "Waiting for health check to pass..."
+          wait_for_container_health(new_container, service[:healthcheck])
+        else
+          @logger.info "No health check configured, waiting for container to be running..."
+          wait_for_container_running(new_container)
+        end
+
+        # Step 4: Update proxy routing to new container
+        if @proxy_manager
+          @logger.info "Switching proxy traffic to new container..."
+          @proxy_manager.switch_traffic(
+            service_name: service_name,
+            from_containers: current_containers,
+            to_container: new_container
+          )
+        else
+          @logger.warn "No proxy manager configured, skipping traffic switch"
+        end
+
+        # Step 5: Gracefully stop old containers
+        if current_containers.any?
+          @logger.info "Stopping #{current_containers.length} old containers..."
+          stop_old_containers(current_containers, service[:drain_timeout] || 30)
+        end
+
+        # Step 6: Clean up old containers
+        cleanup_old_containers(service_name, new_container[:id])
+
+        {
+          service: service_name,
+          old_containers: current_containers.map { |c| c[:id] },
+          new_container: new_container[:id],
+          status: "success"
+        }
+      rescue StandardError => e
+        @logger.error "Failed to deploy #{service_name}: #{e.message}"
+
+        # Cleanup: Remove the new container if deployment failed
+        if defined?(new_container) && new_container
+          @logger.info "Cleaning up failed deployment container..."
+          @adapter.stop_container(new_container[:id], graceful: false)
+        end
+
+        raise DeploymentError, "Zero-downtime deployment failed for #{service_name}: #{e.message}"
+      end
+
+      # Get currently running containers for a service
+      #
+      # @param service_name [String] Service name
+      # @return [Array<Hash>] Array of container information
+      def get_current_containers(service_name)
+        @logger.debug "get_current_containers: Calling adapter.get_running_containers for service: #{service_name}"
+        @adapter.get_running_containers(service_name)
+      rescue StandardError => e
+        @logger.warn "Failed to get current containers for #{service_name}: #{e.message}"
+        @logger.debug "get_current_containers error backtrace: #{e.backtrace.join("\n")}"
+        []
+      end
+
+      # Start a new container for the service
+      #
+      # @param service [Hash] Service configuration
+      # @param image [String] Container image
+      # @param environment [String] Target environment
+      # @return [Hash] New container information
+      def start_new_container(service, image, environment)
+        container_name = generate_container_name(service[:name])
+
+        container_config = {
+          name: container_name,
+          image: image,
+          ports: service[:ports] || [],
+          env: build_environment_variables(service, environment),
+          volumes: service[:volumes] || [],
+          command: service[:cmd],
+          labels: build_container_labels(service, environment),
+          restart_policy: service[:restart_policy] || "unless-stopped"
+        }
+
+        @logger.debug "start_new_container: Calling adapter.start_container with config: #{container_config.inspect}"
+        begin
+          result = @adapter.start_container(container_config)
+          @logger.debug "start_new_container: Result: #{result.inspect}"
+          result
+        rescue StandardError => e
+          @logger.error "start_new_container failed: #{e.message}"
+          @logger.debug "start_new_container error backtrace: #{e.backtrace.join("\n")}"
+          raise
+        end
+      end
+
+      # Build environment variables for container
+      #
+      # @param service [Hash] Service configuration
+      # @param environment [String] Target environment
+      # @return [Hash] Environment variables
+      def build_environment_variables(service, environment)
+        env_vars = {
+          "GJALLARHORN_SERVICE" => service[:name],
+          "GJALLARHORN_ENVIRONMENT" => environment,
+          "GJALLARHORN_DEPLOYED_AT" => Time.now.utc.iso8601
+        }
+
+        # Add service-specific environment variables
+        # Handle both string and symbol keys from YAML
+        service_env = service[:env] || service["env"]
+        env_vars.merge!(service_env) if service_env
+
+        env_vars
+      end
+
+      # Build container labels for identification and management
+      #
+      # @param service [Hash] Service configuration
+      # @param environment [String] Target environment
+      # @return [Hash] Container labels
+      def build_container_labels(service, environment)
+        {
+          "gjallarhorn.service" => service[:name],
+          "gjallarhorn.environment" => environment,
+          "gjallarhorn.role" => service[:role] || "web",
+          "gjallarhorn.deployed_at" => Time.now.utc.iso8601,
+          "gjallarhorn.strategy" => "zero_downtime"
+        }
+      end
+
+      # Wait for container to be in running state
+      #
+      # @param container [Hash] Container information
+      # @param timeout [Integer] Timeout in seconds
+      # @return [Boolean] True when container is running
+      def wait_for_container_running(container, timeout = 60)
+        start_time = Time.now
+
+        loop do
+          status = @adapter.get_container_status(container[:id])
+
+          if status == "running"
+            @logger.info "Container #{container[:name]} is running"
+            return true
+          end
+
+          elapsed = Time.now - start_time
+          if elapsed >= timeout
+            raise DeploymentError,
+                  "Container #{container[:name]} failed to start within #{timeout}s (status: #{status})"
+          end
+
+          @logger.debug "Container #{container[:name]} status: #{status}, waiting..."
+          sleep 2
+        end
+      end
+
+      # Gracefully stop old containers
+      #
+      # @param containers [Array<Hash>] Containers to stop
+      # @param drain_timeout [Integer] Time to wait for graceful shutdown
+      # @return [void]
+      def stop_old_containers(containers, drain_timeout = 30)
+        containers.each do |container|
+          @logger.info "Stopping container: #{container[:name]} (#{container[:id]})"
+
+          begin
+            # Give container time to finish current requests
+            @adapter.stop_container(container[:id], graceful: true, timeout: drain_timeout)
+            @logger.info "Successfully stopped container: #{container[:name]}"
+          rescue StandardError => e
+            @logger.error "Failed to stop container #{container[:name]}: #{e.message}"
+            # Continue with other containers even if one fails
+          end
+        end
+      end
+
+      # Clean up old containers, keeping a configurable number for rollback
+      #
+      # @param service_name [String] Service name
+      # @param exclude_container_id [String] Container ID to exclude from cleanup
+      # @param keep_count [Integer] Number of old containers to keep
+      # @return [void]
+      def cleanup_old_containers(service_name, exclude_container_id, keep_count = 2)
+        all_containers = @adapter.get_all_containers(service_name)
+        old_containers = all_containers.reject { |c| c[:id] == exclude_container_id }
+
+        # Sort by creation time (newest first) and keep only the specified count
+        containers_to_remove = old_containers.sort_by { |c| c[:created_at] }.reverse.drop(keep_count)
+
+        containers_to_remove.each do |container|
+          @logger.info "Removing old container: #{container[:name]} (#{container[:id]})"
+          @adapter.remove_container(container[:id])
+        end
+
+        @logger.info "Cleaned up #{containers_to_remove.length} old containers" if containers_to_remove.any?
+      rescue StandardError => e
+        @logger.warn "Failed to cleanup old containers: #{e.message}"
+        # Don't fail deployment if cleanup fails
+      end
+    end
+
+    # Raised when deployment operations fail
+    class DeploymentError < Error; end
+  end
+end