kdeploy 0.1.0 → 0.3.0

data/lib/kdeploy/pipeline.rb

@@ -1,249 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Pipeline class for managing deployment tasks and hosts
-  class Pipeline
-    attr_reader :name, :hosts, :tasks, :variables
-
-    def initialize(name = 'default')
-      @name = name
-      @hosts = []
-      @tasks = []
-      @variables = {}
-    end
-
-    # Add host to pipeline
-    # @param hostname [String] Hostname or IP address
-    # @param user [String] SSH user
-    # @param port [Integer] SSH port
-    # @param ssh_options [Hash] SSH options
-    # @param roles [Array] Host roles
-    # @param vars [Hash] Host variables
-    # @return [Host] Created host
-    def add_host(hostname, user: nil, port: nil, ssh_options: {}, roles: [], vars: {})
-      host = Host.new(
-        hostname,
-        user: user,
-        port: port,
-        ssh_options: ssh_options,
-        roles: roles,
-        vars: vars
-      )
-      @hosts << host unless @hosts.include?(host)
-      host
-    end
-
-    # Add multiple hosts from hash
-    # @param hosts_config [Hash] Hosts configuration
-    def add_hosts(hosts_config)
-      hosts_config.each do |hostname, config|
-        config ||= {}
-        add_host_from_config(hostname, config)
-      end
-    end
-
-    # Get hosts by role
-    # @param role [String, Symbol] Role to filter by
-    # @return [Array<Host>] Hosts with specified role
-    def hosts_with_role(role)
-      @hosts.select { |host| host.has_role?(role) }
-    end
-
-    # Add task to pipeline
-    # @param name [String] Task name
-    # @param hosts [Array<Host>] Target hosts (default: all hosts)
-    # @param options [Hash] Task options
-    # @return [Task] Created task
-    def add_task(name, hosts: nil, **options)
-      target_hosts = hosts || @hosts
-      task = create_task(name, target_hosts, options)
-      @tasks << task
-      task
-    end
-
-    # Set global variable
-    # @param key [String, Symbol] Variable key
-    # @param value [Object] Variable value
-    def set_variable(key, value)
-      @variables[key.to_s] = value
-    end
-
-    # Get global variable
-    # @param key [String, Symbol] Variable key
-    # @return [Object] Variable value
-    def get_variable(key)
-      @variables[key.to_s] || @variables[key.to_sym]
-    end
-
-    # Execute all tasks in pipeline
-    # @return [Hash] Execution results
-    def execute
-      return empty_execution_result if @tasks.empty?
-
-      log_pipeline_start
-      start_time = Time.now
-      results = execute_tasks
-      duration = Time.now - start_time
-      success_count = count_successful_tasks(results)
-
-      log_pipeline_completion(duration, success_count)
-      build_execution_result(results, duration, success_count)
-    end
-
-    # Get pipeline summary
-    # @return [Hash] Pipeline summary
-    def summary
-      {
-        name: @name,
-        hosts_count: @hosts.size,
-        tasks_count: @tasks.size,
-        hosts: @hosts.map(&:hostname),
-        tasks: @tasks.map(&:name)
-      }
-    end
-
-    # Validate pipeline configuration
-    # @return [Array<String>] Validation errors
-    def validate
-      errors = []
-      errors.concat(validate_pipeline_structure)
-      errors.concat(validate_hosts)
-      errors.concat(validate_tasks)
-      errors
-    end
-
-    # Check if pipeline is valid
-    # @return [Boolean] True if pipeline is valid
-    def valid?
-      validate.empty?
-    end
-
-    private
-
-    def add_host_from_config(hostname, config)
-      add_host(
-        hostname,
-        user: config['user'] || config[:user],
-        port: config['port'] || config[:port],
-        ssh_options: config['ssh_options'] || config[:ssh_options] || {},
-        roles: config['roles'] || config[:roles] || [],
-        vars: config['vars'] || config[:vars] || {}
-      )
-    end
-
-    def create_task(name, target_hosts, options)
-      task = Task.new(name, target_hosts, options)
-      task.global_variables = @variables
-      task
-    end
-
-    def empty_execution_result
-      { success: true, results: [], duration: 0 }
-    end
-
-    def log_pipeline_start
-      KdeployLogger.info(
-        "Starting pipeline '#{@name}' with #{@tasks.size} task(s) on #{@hosts.size} host(s)"
-      )
-    end
-
-    def execute_tasks
-      results = []
-      overall_success = true
-
-      @tasks.each_with_index do |task, index|
-        log_task_execution(task, index)
-        result = execute_task(task)
-        results << result
-        overall_success = false unless result[:success]
-      end
-
-      results
-    end
-
-    def log_task_execution(task, index)
-      KdeployLogger.info("Executing task #{index + 1}/#{@tasks.size}: '#{task.name}'")
-    end
-
-    def execute_task(task)
-      result = task.execute
-      log_task_failure(task) unless result[:success]
-
-      {
-        task_name: task.name,
-        **result
-      }
-    end
-
-    def log_task_failure(task)
-      KdeployLogger.error("Task '#{task.name}' failed, pipeline execution continuing...")
-    end
-
-    def count_successful_tasks(results)
-      results.count { |r| r[:success] }
-    end
-
-    def log_pipeline_completion(duration, success_count)
-      KdeployLogger.info(
-        "Pipeline '#{@name}' completed in #{duration.round(2)}s: " \
-        "#{success_count}/#{@tasks.size} tasks successful"
-      )
-    end
-
-    def build_execution_result(results, duration, success_count)
-      {
-        success: results.all? { |r| r[:success] },
-        results: results,
-        duration: duration,
-        tasks_count: @tasks.size,
-        success_count: success_count
-      }
-    end
-
-    def validate_pipeline_structure
-      errors = []
-      errors << 'No hosts defined' if @hosts.empty?
-      errors << 'No tasks defined' if @tasks.empty?
-      errors
-    end
-
-    def validate_hosts
-      @hosts.each_with_object([]) do |host, errors|
-        errors.concat(validate_host(host))
-      end
-    end
-
-    def validate_host(host)
-      errors = []
-      errors << "Invalid hostname: #{host.hostname}" if invalid_hostname?(host)
-      errors << "Invalid user: #{host.user}" if invalid_user?(host)
-      errors << "Invalid port: #{host.port}" if invalid_port?(host)
-      errors
-    end
-
-    def invalid_hostname?(host)
-      host.hostname.nil? || host.hostname.empty?
-    end
-
-    def invalid_user?(host)
-      host.user.nil? || host.user.empty?
-    end
-
-    def invalid_port?(host)
-      !host.port.is_a?(Integer) || !host.port.positive?
-    end
-
-    def validate_tasks
-      @tasks.each_with_object([]) do |task, errors|
-        errors.concat(validate_task(task))
-      end
-    end
-
-    def validate_task(task)
-      errors = []
-      errors << "Task '#{task.name}' has no commands" if task.commands.empty?
-      errors << "Task '#{task.name}' has no hosts" if task.hosts.empty?
-      errors
-    end
-  end
-end

data/lib/kdeploy/ssh_connection.rb

@@ -1,187 +0,0 @@
-# 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