gjallarhorn 0.1.0.alpha → 0.1.0

data/lib/gjallarhorn/history.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "time"
+
+module Gjallarhorn
+  # Deployment history tracking and management
+  #
+  # Handles tracking of deployment history in a local JSON file,
+  # providing functionality to record deployments and query history.
+  #
+  # @since 0.1.0
+  class History
+    # Default directory for storing history files
+    DEFAULT_HISTORY_DIR = File.expand_path("~/.gjallarhorn")
+    
+    # Default filename for history storage
+    DEFAULT_HISTORY_FILE = "history.json"
+
+    # Initialize history manager
+    #
+    # @param history_dir [String] Directory to store history files
+    def initialize(history_dir: DEFAULT_HISTORY_DIR)
+      @history_dir = history_dir
+      @history_file = File.join(@history_dir, DEFAULT_HISTORY_FILE)
+      ensure_history_directory
+    end
+
+    # Record a deployment attempt
+    #
+    # @param environment [String] Environment name
+    # @param image [String] Container image deployed
+    # @param status [String] Deployment status ('success', 'failed', 'started')
+    # @param strategy [String] Deployment strategy used (optional)
+    # @param error [String] Error message if deployment failed (optional)
+    # @return [void]
+    def record_deployment(environment:, image:, status:, strategy: nil, error: nil)
+      deployment_record = {
+        timestamp: Time.now.utc.iso8601,
+        environment: environment,
+        image: image,
+        status: status,
+        strategy: strategy,
+        error: error
+      }.compact
+
+      history_data = load_history
+      history_data << deployment_record
+
+      # Keep only the last 100 deployments to prevent file from growing too large
+      history_data = history_data.last(100) if history_data.length > 100
+
+      save_history(history_data)
+    end
+
+    # Get deployment history for a specific environment
+    #
+    # @param environment [String] Environment name (optional, returns all if nil)
+    # @param limit [Integer] Maximum number of records to return
+    # @return [Array<Hash>] Array of deployment records
+    def get_history(environment: nil, limit: 20)
+      history_data = load_history
+
+      # Filter by environment if specified
+      if environment
+        history_data = history_data.select { |record| record["environment"] == environment }
+      end
+
+      # Sort by timestamp (most recent first) and limit results
+      history_data.sort_by { |record| record["timestamp"] }.reverse.first(limit)
+    end
+
+    # Get the last successful deployment for an environment
+    #
+    # @param environment [String] Environment name
+    # @return [Hash, nil] Last successful deployment record or nil if none found
+    def last_successful_deployment(environment)
+      history_data = load_history
+      
+      history_data
+        .select { |record| record["environment"] == environment && record["status"] == "success" }
+        .sort_by { |record| record["timestamp"] }
+        .last
+    end
+
+    # Get available versions for rollback
+    #
+    # @param environment [String] Environment name
+    # @param limit [Integer] Maximum number of versions to return
+    # @return [Array<String>] Array of available image tags
+    def available_versions(environment, limit: 10)
+      successful_deployments = get_history(environment: environment, limit: 50)
+        .select { |record| record["status"] == "success" }
+        .uniq { |record| record["image"] }
+
+      successful_deployments.first(limit).map { |record| record["image"] }
+    end
+
+    # Clear history for a specific environment or all environments
+    #
+    # @param environment [String] Environment name (optional, clears all if nil)
+    # @return [void]
+    def clear_history(environment: nil)
+      if environment
+        history_data = load_history.reject { |record| record["environment"] == environment }
+        save_history(history_data)
+      else
+        save_history([])
+      end
+    end
+
+    # Get deployment statistics
+    #
+    # @param environment [String] Environment name (optional)
+    # @return [Hash] Statistics about deployments
+    def statistics(environment: nil)
+      history_data = load_history
+      
+      if environment
+        history_data = history_data.select { |record| record["environment"] == environment }
+      end
+
+      total = history_data.length
+      successful = history_data.count { |record| record["status"] == "success" }
+      failed = history_data.count { |record| record["status"] == "failed" }
+
+      {
+        total_deployments: total,
+        successful_deployments: successful,
+        failed_deployments: failed,
+        success_rate: total > 0 ? (successful.to_f / total * 100).round(2) : 0
+      }
+    end
+
+    private
+
+    # Ensure the history directory exists
+    #
+    # @return [void]
+    def ensure_history_directory
+      FileUtils.mkdir_p(@history_dir) unless Dir.exist?(@history_dir)
+    end
+
+    # Load history data from file
+    #
+    # @return [Array<Hash>] Array of deployment records
+    def load_history
+      return [] unless File.exist?(@history_file)
+
+      JSON.parse(File.read(@history_file))
+    rescue JSON::ParserError, Errno::ENOENT
+      []
+    end
+
+    # Save history data to file
+    #
+    # @param history_data [Array<Hash>] Array of deployment records
+    # @return [void]
+    def save_history(history_data)
+      File.write(@history_file, JSON.pretty_generate(history_data))
+    end
+  end
+end

data/lib/gjallarhorn/proxy/kamal_proxy_manager.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "manager"
+
+module Gjallarhorn
+  module Proxy
+    # Kamal-proxy manager for zero-downtime deployments
+    #
+    # This is a placeholder implementation for kamal-proxy support.
+    # Full implementation will be added in a future release.
+    #
+    # @since 0.1.0
+    class KamalProxyManager < Manager
+      # Switch traffic from old containers to new container
+      #
+      # @param service_name [String] Service name
+      # @param from_containers [Array<Hash>] Containers to switch traffic from
+      # @param to_container [Hash] Container to switch traffic to
+      # @return [void]
+      def switch_traffic(service_name:, from_containers:, to_container:)
+        raise NotImplementedError, "Kamal-proxy support not yet implemented"
+      end
+
+      # Get kamal-proxy status
+      #
+      # @return [Hash] Kamal-proxy status information
+      def status
+        {
+          type: "kamal-proxy",
+          status: "not_implemented",
+          upstreams: []
+        }
+      end
+    end
+  end
+end

data/lib/gjallarhorn/proxy/manager.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Gjallarhorn
+  module Proxy
+    # Base proxy manager class
+    #
+    # Handles traffic routing and switching during deployments.
+    # Supports different proxy types (nginx, traefik, kamal-proxy)
+    # for zero-downtime deployments.
+    #
+    # @since 0.1.0
+    class Manager
+      attr_reader :config, :proxy_type, :logger
+
+      # Initialize proxy manager
+      #
+      # @param config [Hash] Proxy configuration
+      # @param logger [Logger] Logger instance
+      def initialize(config, logger = nil)
+        @config = config
+        @proxy_type = config[:type] || "nginx"
+        @logger = logger || Logger.new($stdout)
+      end
+
+      # Switch traffic from old containers to new container
+      #
+      # @param service_name [String] Service name
+      # @param from_containers [Array<Hash>] Containers to switch traffic from
+      # @param to_container [Hash] Container to switch traffic to
+      # @abstract Subclasses should implement this method
+      # @return [void]
+      def switch_traffic(service_name:, from_containers:, to_container:)
+        raise NotImplementedError, "Subclasses must implement switch_traffic"
+      end
+
+      # Get proxy status
+      #
+      # @return [Hash] Proxy status information
+      def status
+        {
+          type: @proxy_type,
+          status: "unknown",
+          upstreams: []
+        }
+      end
+
+      # Restart proxy service
+      #
+      # @return [Boolean] True if restart successful
+      def restart
+        @logger.info "Restarting #{@proxy_type} proxy..."
+        false # Default implementation
+      end
+
+      # Check if proxy is healthy
+      #
+      # @return [Boolean] True if proxy is responding
+      def healthy?
+        false # Default implementation
+      end
+
+      # Create appropriate proxy manager based on configuration
+      #
+      # @param config [Hash] Proxy configuration
+      # @param logger [Logger] Logger instance
+      # @return [Manager] Proxy manager instance
+      def self.create(config, logger = nil)
+        case config[:type]
+        when "nginx"
+          NginxManager.new(config, logger)
+        when "traefik"
+          TraefikManager.new(config, logger)
+        when "kamal-proxy"
+          KamalProxyManager.new(config, logger)
+        else
+          raise ConfigurationError, "Unsupported proxy type: #{config[:type]}"
+        end
+      end
+
+      protected
+
+      # Verify that traffic switch was successful
+      #
+      # @param service_name [String] Service name
+      # @param container [Hash] Container that should be receiving traffic
+      # @param max_attempts [Integer] Maximum verification attempts
+      # @return [Boolean] True if verification successful
+      def verify_traffic_switch(service_name, container, max_attempts = 10)
+        return true unless @config[:domain] # Skip verification if no domain configured
+
+        attempts = 0
+        url = build_health_check_url(service_name)
+
+        loop do
+          if traffic_reaching_container?(url, container)
+            @logger.info "Traffic switch verification successful for #{service_name}"
+            return true
+          end
+
+          attempts += 1
+          if attempts >= max_attempts
+            @logger.error "Traffic switch verification failed after #{max_attempts} attempts"
+            return false
+          end
+
+          @logger.debug "Traffic switch verification attempt #{attempts}/#{max_attempts}..."
+          sleep 2
+        end
+      end
+
+      # Build health check URL for traffic verification
+      #
+      # @param service_name [String] Service name
+      # @return [String] Health check URL
+      def build_health_check_url(_service_name)
+        protocol = @config[:ssl] ? "https" : "http"
+        domain = @config[:domain] || @config[:host]
+        path = @config[:health_check_path] || "/health"
+
+        "#{protocol}://#{domain}#{path}"
+      end
+
+      # Check if traffic is reaching the specified container
+      #
+      # @param url [String] URL to check
+      # @param container [Hash] Container information
+      # @return [Boolean] True if traffic is reaching container
+      def traffic_reaching_container?(url, container)
+        require "net/http"
+        require "uri"
+
+        begin
+          uri = URI(url)
+          response = Net::HTTP.get_response(uri)
+
+          # Check if response headers indicate traffic is coming from new container
+          container_header = response["X-Container-ID"] || response["X-Container-Name"]
+          if container_header
+            container_header == container[:id] || container_header == container[:name]
+          else
+            # If no container headers, assume success if we get a successful response
+            response.code.to_i.between?(200, 299)
+          end
+        rescue StandardError => e
+          @logger.debug "Traffic verification request failed: #{e.message}"
+          false
+        end
+      end
+
+      # Generate upstream configuration block
+      #
+      # @param service_name [String] Service name
+      # @param containers [Array<Hash>] Container information
+      # @return [String] Upstream configuration
+      def generate_upstream_config(service_name, containers)
+        servers = containers.map do |container|
+          host = container[:ip] || container[:host] || "localhost"
+          port = extract_port_from_container(container)
+          "    server #{host}:#{port};"
+        end
+
+        <<~CONFIG
+          upstream #{service_name} {
+          #{servers.join("\n")}
+          }
+        CONFIG
+      end
+
+      # Extract port from container configuration
+      #
+      # @param container [Hash] Container information
+      # @return [Integer] Port number
+      def extract_port_from_container(container)
+        # Try to get port from container port mappings
+        if container[:ports]&.any?
+          # Format: ["80:3000"] -> extract the container port (3000)
+          port_mapping = container[:ports].first
+          port_mapping.split(":").last.to_i
+        else
+          # Default to app_port from config or 3000
+          @config[:app_port] || 3000
+        end
+      end
+    end
+  end
+end