kdeploy 0.1.0

data/lib/kdeploy/runner.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  class Runner
+    attr_reader :pipeline
+
+    def initialize(pipeline)
+      @pipeline = pipeline
+    end
+
+    # Execute the deployment pipeline
+    # @return [Hash] Execution results
+    def execute
+      validate_pipeline!
+      setup_logging
+
+      KdeployLogger.info("Starting deployment: #{@pipeline.name}")
+      KdeployLogger.info("Pipeline summary: #{@pipeline.summary}")
+
+      start_time = Time.now
+
+      begin
+        result = @pipeline.execute
+
+        duration = Time.now - start_time
+
+        # Enhanced result with pipeline info for statistics
+        enhanced_result = result.merge(
+          pipeline_name: @pipeline.name,
+          hosts_count: @pipeline.hosts.size
+        )
+
+        # Record deployment statistics
+        Kdeploy.statistics.record_deployment(enhanced_result)
+
+        log_final_results(enhanced_result, duration)
+
+        enhanced_result
+      rescue StandardError => e
+        duration = Time.now - start_time
+        KdeployLogger.fatal("Deployment failed after #{duration.round(2)}s: #{e.message}")
+        KdeployLogger.debug("Error backtrace: #{e.backtrace.join("\n")}")
+
+        failed_result = {
+          success: false,
+          error: e.message,
+          duration: duration,
+          results: [],
+          pipeline_name: @pipeline.name,
+          hosts_count: @pipeline.hosts.size,
+          tasks_count: @pipeline.tasks.size,
+          success_count: 0
+        }
+
+        # Record failed deployment statistics
+        Kdeploy.statistics.record_deployment(failed_result)
+
+        failed_result
+      end
+    end
+
+    # Dry run - validate and show what would be executed
+    # @return [Hash] Validation results and execution plan
+    def dry_run
+      KdeployLogger.info("Performing dry run for pipeline: #{@pipeline.name}")
+
+      validation_errors = @pipeline.validate
+
+      if validation_errors.any?
+        KdeployLogger.error('Pipeline validation failed:')
+        validation_errors.each { |error| KdeployLogger.error("  - #{error}") }
+
+        return {
+          success: false,
+          validation_errors: validation_errors,
+          execution_plan: nil
+        }
+      end
+
+      execution_plan = generate_execution_plan
+
+      KdeployLogger.info('Dry run completed successfully')
+      log_execution_plan(execution_plan)
+
+      {
+        success: true,
+        validation_errors: [],
+        execution_plan: execution_plan
+      }
+    end
+
+    private
+
+    def validate_pipeline!
+      validation_errors = @pipeline.validate
+
+      return if validation_errors.empty?
+
+      error_message = "Pipeline validation failed:\n#{validation_errors.map { |e| "  - #{e}" }.join("\n")}"
+      raise ConfigurationError, error_message
+    end
+
+    def setup_logging
+      config = Kdeploy.configuration
+      return unless config
+
+      KdeployLogger.setup(
+        level: config.log_level,
+        file: config.log_file
+      )
+    end
+
+    def log_final_results(result, duration)
+      if result[:success]
+        KdeployLogger.info("✅ Deployment completed successfully in #{duration.round(2)}s")
+        KdeployLogger.info("📊 Summary: #{result[:success_count]}/#{result[:tasks_count]} tasks successful")
+      else
+        KdeployLogger.error("❌ Deployment failed in #{duration.round(2)}s")
+        KdeployLogger.error("📊 Summary: #{result[:success_count]}/#{result[:tasks_count]} tasks successful")
+      end
+
+      # Log task details
+      if result[:results].is_a?(Array)
+        result[:results].each do |task_result|
+          status = task_result[:success] ? '✅' : '❌'
+          success_info = "#{task_result[:success_count]}/#{task_result[:hosts_count]} hosts successful"
+          KdeployLogger.info("#{status} Task '#{task_result[:task_name]}': #{success_info}")
+        end
+      end
+
+      # Log statistics summary
+      global_stats = Kdeploy.statistics.global_summary
+      KdeployLogger.info("📈 Global Stats: #{global_stats[:total_deployments]} deployments, " \
+                         "#{global_stats[:successful_deployments]} successful, " \
+                         "#{global_stats[:failed_deployments]} failed")
+    end
+
+    def generate_execution_plan
+      plan = {
+        pipeline_name: @pipeline.name,
+        total_hosts: @pipeline.hosts.size,
+        total_tasks: @pipeline.tasks.size,
+        hosts: @pipeline.hosts.map(&:hostname),
+        tasks: []
+      }
+
+      @pipeline.tasks.each do |task|
+        task_plan = {
+          name: task.name,
+          target_hosts: task.hosts.map(&:hostname),
+          commands: task.commands.map do |command|
+            {
+              name: command.name,
+              command: command.command,
+              options: command.options
+            }
+          end,
+          options: task.options
+        }
+
+        plan[:tasks] << task_plan
+      end
+
+      plan
+    end
+
+    def log_execution_plan(plan)
+      KdeployLogger.info('📋 Execution Plan:')
+      KdeployLogger.info("  Pipeline: #{plan[:pipeline_name]}")
+      KdeployLogger.info("  Hosts: #{plan[:total_hosts]} (#{plan[:hosts].join(', ')})")
+      KdeployLogger.info("  Tasks: #{plan[:total_tasks]}")
+
+      plan[:tasks].each_with_index do |task, index|
+        KdeployLogger.info("    #{index + 1}. #{task[:name]}")
+        KdeployLogger.info("       Targets: #{task[:target_hosts].join(', ')}")
+        KdeployLogger.info("       Commands: #{task[:commands].size}")
+
+        task[:commands].each_with_index do |command, cmd_index|
+          KdeployLogger.info("         #{cmd_index + 1}. #{command[:name]}: #{command[:command]}")
+        end
+
+        if task[:options][:parallel]
+          KdeployLogger.info("       Execution: Parallel (max: #{task[:options][:max_concurrent] || 'unlimited'})")
+        else
+          KdeployLogger.info('       Execution: Sequential')
+        end
+      end
+    end
+  end
+end

data/lib/kdeploy/ssh_connection.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  # SSHConnection class for managing SSH connections to remote hosts
+  class SSHConnection
+    attr_reader :host, :session
+
+    def initialize(host)
+      @host = host
+      @session = nil
+      @connected = false
+    end
+
+    # Establish SSH connection
+    # @return [Boolean] True if connection successful
+    # @raise [ConnectionError] If connection fails
+    def connect
+      return true if connected?
+
+      KdeployLogger.debug("Connecting to #{@host}")
+      establish_connection
+      KdeployLogger.debug("Connected to #{@host}")
+      true
+    rescue Net::SSH::Exception => e
+      handle_connection_error(e)
+    end
+
+    # Check if connection is active
+    # @return [Boolean] True if connected
+    def connected?
+      @connected && @session && !@session.closed?
+    end
+
+    # Execute command on remote host
+    # @param command [String] Command to execute
+    # @param timeout [Integer] Command timeout in seconds
+    # @return [Hash] Result with stdout, stderr, exit_code, and success
+    def execute(command, timeout: nil)
+      ensure_connected
+
+      result = initialize_result
+      timeout ||= Kdeploy.configuration&.command_timeout || 300
+
+      KdeployLogger.debug("Executing on #{@host}: #{command}")
+      execute_command(command, result)
+      KdeployLogger.debug("Command completed on #{@host}: exit_code=#{result[:exit_code]}")
+
+      result
+    rescue Net::SSH::Exception => e
+      handle_execution_error(e)
+    end
+
+    # Upload file to remote host
+    # @param local_path [String] Local file path
+    # @param remote_path [String] Remote file path
+    # @return [Boolean] True if upload successful
+    def upload(local_path, remote_path)
+      ensure_connected
+
+      KdeployLogger.debug("Uploading #{local_path} to #{@host}:#{remote_path}")
+      perform_upload(local_path, remote_path)
+      KdeployLogger.debug("Upload completed: #{local_path} -> #{@host}:#{remote_path}")
+      true
+    rescue Net::SCP::Error => e
+      handle_upload_error(e, local_path, remote_path)
+    end
+
+    # Download file from remote host
+    # @param remote_path [String] Remote file path
+    # @param local_path [String] Local file path
+    # @return [Boolean] True if download successful
+    def download(remote_path, local_path)
+      ensure_connected
+
+      KdeployLogger.debug("Downloading #{@host}:#{remote_path} to #{local_path}")
+      perform_download(remote_path, local_path)
+      KdeployLogger.debug("Download completed: #{@host}:#{remote_path} -> #{local_path}")
+      true
+    rescue Net::SCP::Error => e
+      handle_download_error(e, remote_path, local_path)
+    end
+
+    # Close SSH connection
+    def disconnect
+      return unless @session
+
+      @session.close unless @session.closed?
+      @session = nil
+      @connected = false
+      KdeployLogger.debug("Disconnected from #{@host}")
+    end
+
+    # Clean up connection
+    def cleanup
+      disconnect
+    end
+
+    private
+
+    def establish_connection
+      @session = Net::SSH.start(
+        @host.hostname,
+        @host.user,
+        port: @host.port,
+        **@host.connection_options
+      )
+      @connected = true
+    end
+
+    def handle_connection_error(error)
+      KdeployLogger.error("Failed to connect to #{@host}: #{error.message}")
+      raise ConnectionError, "Failed to connect to #{@host}: #{error.message}"
+    end
+
+    def ensure_connected
+      connect unless connected?
+      raise ConnectionError, "Not connected to #{@host}" unless connected?
+    end
+
+    def initialize_result
+      {
+        stdout: '',
+        stderr: '',
+        exit_code: nil,
+        success: false
+      }
+    end
+
+    def execute_command(command, result)
+      channel = create_command_channel(command, result)
+      channel.wait
+      result[:success] = result[:exit_code]&.zero? || false
+    end
+
+    def create_command_channel(command, result)
+      @session.open_channel do |ch|
+        ch.exec(command) do |ch, success|
+          handle_command_execution(ch, success, result)
+        end
+      end
+    end
+
+    def handle_command_execution(channel, success, result)
+      unless success
+        result[:stderr] = 'Failed to execute command'
+        result[:exit_code] = 1
+        return
+      end
+
+      setup_command_callbacks(channel, result)
+    end
+
+    def setup_command_callbacks(channel, result)
+      channel.on_data { |_ch, data| result[:stdout] += data }
+      channel.on_extended_data { |_ch, _type, data| result[:stderr] += data }
+      channel.on_request('exit-status') { |_ch, data| result[:exit_code] = data.read_long }
+    end
+
+    def handle_execution_error(error)
+      KdeployLogger.error("SSH execution error on #{@host}: #{error.message}")
+      {
+        stdout: '',
+        stderr: error.message,
+        exit_code: 1,
+        success: false
+      }
+    end
+
+    def perform_upload(local_path, remote_path)
+      @session.scp.upload!(local_path, remote_path)
+    end
+
+    def handle_upload_error(error, local_path, remote_path)
+      KdeployLogger.error("Upload failed #{local_path} -> #{@host}:#{remote_path}: #{error.message}")
+      false
+    end
+
+    def perform_download(remote_path, local_path)
+      @session.scp.download!(remote_path, local_path)
+    end
+
+    def handle_download_error(error, remote_path, local_path)
+      KdeployLogger.error("Download failed #{@host}:#{remote_path} -> #{local_path}: #{error.message}")
+      false
+    end
+  end
+end