kdeploy 0.1.0 → 0.3.0

data/lib/kdeploy/command.rb

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Command class for executing commands on remote hosts
-  class Command
-    attr_reader :name, :command, :options, :result
-
-    def initialize(name, command, options = {})
-      @name = name
-      @command = command
-      @options = default_options.merge(options)
-      @global_variables = options.delete(:global_variables) || {}
-      @result = nil
-    end
-
-    # Execute command on specified host
-    # @param host [Host] Target host
-    # @param connection [SSHConnection] SSH connection
-    # @return [Boolean] True if command succeeded
-    def execute(host, connection)
-      start_time = Time.now
-      processed_command = process_command_template(host)
-
-      log_command_start(host, processed_command)
-      @result = execute_with_retry(connection, processed_command)
-      duration = Time.now - start_time
-
-      log_result(host, duration)
-      record_statistics(host.hostname, duration, @result[:success])
-
-      @result[:success]
-    rescue StandardError => e
-      handle_execution_error(host, e, start_time)
-    end
-
-    # Check if command should run on host
-    # @param host [Host] Target host
-    # @return [Boolean] True if command should run
-    def should_run_on?(host)
-      return true unless @options[:only] || @options[:except]
-
-      if @options[:only]
-        roles = Array(@options[:only])
-        return roles.any? { |role| host.has_role?(role) }
-      end
-
-      if @options[:except]
-        roles = Array(@options[:except])
-        return roles.none? { |role| host.has_role?(role) }
-      end
-
-      true
-    end
-
-    private
-
-    def default_options
-      {
-        timeout: nil,
-        retry_count: nil,
-        retry_delay: nil,
-        ignore_errors: false,
-        only: nil,
-        except: nil
-      }
-    end
-
-    def process_command_template(host)
-      processed = @command.dup
-      process_global_variables(processed)
-      process_host_variables(processed, host)
-      process_host_info(processed, host)
-    end
-
-    def process_global_variables(command)
-      @global_variables.each_with_object(command) do |(key, value), cmd|
-        cmd.gsub!("{{#{key}}}", value.to_s)
-        cmd.gsub!("${#{key}}", value.to_s)
-      end
-    end
-
-    def process_host_variables(command, host)
-      host.vars.each_with_object(command) do |(key, value), cmd|
-        cmd.gsub!("{{#{key}}}", value.to_s)
-        cmd.gsub!("${#{key}}", value.to_s)
-      end
-    end
-
-    def process_host_info(command, host)
-      command.gsub('{{hostname}}', host.hostname)
-        .gsub('{{user}}', host.user)
-        .gsub('{{port}}', host.port.to_s)
-    end
-
-    def execute_with_retry(connection, command)
-      retry_count = @options[:retry_count] || Kdeploy.configuration&.retry_count || 0
-      retry_delay = @options[:retry_delay] || Kdeploy.configuration&.retry_delay || 1
-
-      result = nil
-      attempts = 0
-
-      loop do
-        attempts += 1
-        result = connection.execute(command, timeout: @options[:timeout])
-
-        break if result[:success] || attempts > retry_count
-
-        if attempts <= retry_count
-          log_retry_attempt(attempts, retry_count, retry_delay)
-          sleep(retry_delay)
-        end
-      end
-
-      result
-    end
-
-    def log_command_start(host, command)
-      KdeployLogger.info("🚀 Executing '#{@name}' on #{host}")
-      KdeployLogger.debug("   Command: #{command}")
-    end
-
-    def log_retry_attempt(attempts, retry_count, retry_delay)
-      KdeployLogger.warn(
-        "Command '#{@name}' failed (attempt #{attempts}/#{retry_count + 1}), " \
-        "retrying in #{retry_delay}s..."
-      )
-    end
-
-    def log_result(host, duration)
-      if @result[:success]
-        log_success(host, duration)
-      else
-        log_failure(host, duration)
-      end
-    end
-
-    def log_success(host, duration)
-      KdeployLogger.info("✅ Command '#{@name}' completed on #{host} in #{duration.round(2)}s")
-      return if @result[:stdout].strip.empty?
-
-      KdeployLogger.info('📤 Output:')
-      @result[:stdout].strip.split("\n").each do |line|
-        KdeployLogger.info("   #{line}")
-      end
-    end
-
-    def log_failure(host, duration)
-      level = @options[:ignore_errors] ? :warn : :error
-      icon = @options[:ignore_errors] ? '⚠️' : '❌'
-
-      KdeployLogger.send(
-        level,
-        "#{icon} Command '#{@name}' failed on #{host} in #{duration.round(2)}s " \
-        "(exit code: #{@result[:exit_code]})"
-      )
-
-      KdeployLogger.send(level, "📤 STDERR: #{@result[:stderr]}") unless @result[:stderr].empty?
-      KdeployLogger.send(level, "📤 STDOUT: #{@result[:stdout]}") unless @result[:stdout].strip.empty?
-    end
-
-    def handle_execution_error(host, error, start_time)
-      duration = Time.now - start_time
-      KdeployLogger.error(
-        "Command '#{@name}' failed on #{host} after #{duration.round(2)}s: #{error.message}"
-      )
-
-      @result = {
-        stdout: '',
-        stderr: error.message,
-        exit_code: 1,
-        success: false
-      }
-
-      record_statistics(host.hostname, duration, false)
-      false
-    end
-
-    def record_statistics(hostname, duration, success)
-      Kdeploy.statistics.record_command(@name, hostname, success, duration)
-    end
-  end
-end

data/lib/kdeploy/configuration.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Configuration class for managing global settings
-  class Configuration
-    attr_accessor :max_concurrent_tasks, :ssh_timeout, :command_timeout,
-                  :retry_count, :retry_delay, :log_level, :log_file,
-                  :default_user, :default_port, :ssh_options, :inventory_file,
-                  :template_dir
-
-    def initialize
-      set_default_values
-    end
-
-    # Load configuration from YAML file
-    # @param config_file [String] Path to configuration file
-    # @return [void]
-    def load_from_file(config_file)
-      return unless File.exist?(config_file)
-
-      config = YAML.load_file(config_file)
-      return unless config.is_a?(Hash)
-
-      apply_configuration(config)
-    end
-
-    # Merge SSH options with defaults
-    # @param options [Hash] SSH options to merge
-    # @return [Hash] Merged SSH options
-    def merged_ssh_options(options = {})
-      ssh_options.merge(options)
-    end
-
-    private
-
-    def set_default_values
-      set_default_timeouts
-      set_default_retry_settings
-      set_default_logging
-      set_default_ssh_settings
-      set_default_paths
-    end
-
-    def set_default_timeouts
-      @max_concurrent_tasks = 10
-      @ssh_timeout = 30
-      @command_timeout = 300
-    end
-
-    def set_default_retry_settings
-      @retry_count = 3
-      @retry_delay = 1
-    end
-
-    def set_default_logging
-      @log_level = :info
-      @log_file = nil
-    end
-
-    def set_default_ssh_settings
-      @default_user = ENV.fetch('USER', 'root')
-      @default_port = 22
-      @ssh_options = {
-        verify_host_key: :never,
-        non_interactive: true,
-        use_agent: true,
-        forward_agent: false
-      }
-    end
-
-    def set_default_paths
-      @inventory_file = 'inventory.yml'
-      @template_dir = 'templates'
-    end
-
-    def apply_configuration(config)
-      config.each do |key, value|
-        method_name = "#{key}="
-        send(method_name, value) if respond_to?(method_name)
-      end
-    end
-  end
-end

data/lib/kdeploy/host.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Host class for managing remote host configuration and connection details
-  class Host
-    attr_reader :hostname, :user, :port, :ssh_options, :roles, :vars
-
-    def initialize(hostname, user: nil, port: nil, ssh_options: {}, roles: [], vars: {})
-      @hostname = hostname
-      @user = user || Kdeploy.configuration&.default_user || ENV.fetch('USER', nil)
-      @port = port || Kdeploy.configuration&.default_port || 22
-      @ssh_options = ssh_options
-      @roles = Array(roles)
-      @vars = vars || {}
-    end
-
-    # Check if host has specific role
-    # @param role [String, Symbol] Role to check
-    # @return [Boolean] True if host has role
-    def has_role?(role)
-      @roles.include?(role.to_s) || @roles.include?(role.to_sym)
-    end
-
-    # Get variable value
-    # @param key [String, Symbol] Variable key
-    # @return [Object] Variable value
-    def var(key)
-      @vars[key.to_s] || @vars[key.to_sym]
-    end
-
-    # Set variable value
-    # @param key [String, Symbol] Variable key
-    # @param value [Object] Variable value
-    # @return [Object] Set value
-    def set_var(key, value)
-      @vars[key.to_s] = value
-    end
-
-    # Get connection string for display
-    # @return [String] Connection string
-    def connection_string
-      "#{@user}@#{@hostname}:#{@port}"
-    end
-
-    # Get SSH connection options
-    # @return [Hash] SSH options
-    def connection_options
-      base_options = Kdeploy.configuration&.merged_ssh_options(@ssh_options) || @ssh_options
-      base_options.merge(
-        timeout: Kdeploy.configuration&.ssh_timeout || 30
-      )
-    end
-
-    # String representation of the host
-    # @return [String] Connection string
-    def to_s
-      connection_string
-    end
-
-    # Detailed string representation of the host
-    # @return [String] Host details
-    def inspect
-      "#<Kdeploy::Host #{connection_string} roles=#{@roles} vars=#{@vars.keys}>"
-    end
-
-    # Compare hosts for equality
-    # @param other [Host] Host to compare with
-    # @return [Boolean] True if hosts are equal
-    def ==(other)
-      return false unless other.is_a?(Host)
-
-      hostname == other.hostname &&
-        user == other.user &&
-        port == other.port
-    end
-
-    alias eql? ==
-
-    # Generate hash code for host
-    # @return [Integer] Hash code
-    def hash
-      [hostname, user, port].hash
-    end
-  end
-end

data/lib/kdeploy/inventory.rb

@@ -1,243 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Inventory class for managing host inventory and configuration
-  class Inventory
-    attr_reader :hosts, :groups, :vars
-
-    def initialize(inventory_file = nil)
-      @hosts = {}
-      @groups = {}
-      @vars = {}
-      load_from_file(inventory_file) if inventory_file && File.exist?(inventory_file)
-    end
-
-    # Load inventory from YAML file
-    # @param inventory_file [String] Path to inventory file
-    # @raise [ConfigurationError] If inventory file is invalid
-    def load_from_file(inventory_file)
-      inventory_data = YAML.load_file(inventory_file)
-      parse_inventory(inventory_data)
-    rescue Psych::SyntaxError => e
-      raise ConfigurationError, "Invalid YAML syntax in inventory file: #{e.message}"
-    rescue StandardError => e
-      raise ConfigurationError, "Failed to load inventory file: #{e.message}"
-    end
-
-    # Get all hosts in a group
-    # @param group_name [String, Symbol] Group name
-    # @return [Array<Host>] Hosts in the group
-    def hosts_in_group(group_name)
-      group_name = group_name.to_s
-      return [] unless @groups[group_name]
-
-      @groups[group_name][:hosts].map { |hostname| @hosts[hostname] }.compact
-    end
-
-    # Get all hosts with specific role
-    # @param role [String, Symbol] Role name
-    # @return [Array<Host>] Hosts with the role
-    def hosts_with_role(role)
-      @hosts.values.select { |host| host.has_role?(role) }
-    end
-
-    # Get all hosts
-    # @return [Array<Host>] All hosts
-    def all_hosts
-      @hosts.values
-    end
-
-    # Get host by hostname
-    # @param hostname [String] Hostname
-    # @return [Host, nil] Host object or nil
-    def host(hostname)
-      @hosts[hostname]
-    end
-
-    # Get group variable
-    # @param group_name [String, Symbol] Group name
-    # @param var_name [String, Symbol] Variable name
-    # @return [Object] Variable value
-    def group_var(group_name, var_name)
-      group_name = group_name.to_s
-      return nil unless @groups[group_name]
-
-      @groups[group_name][:vars][var_name.to_s] || @groups[group_name][:vars][var_name.to_sym]
-    end
-
-    # Get global variable
-    # @param var_name [String, Symbol] Variable name
-    # @return [Object] Variable value
-    def global_var(var_name)
-      @vars[var_name.to_s] || @vars[var_name.to_sym]
-    end
-
-    # Export inventory summary
-    # @return [Hash] Inventory summary
-    def summary
-      {
-        total_hosts: @hosts.size,
-        total_groups: @groups.size,
-        hosts: @hosts.keys,
-        groups: @groups.keys
-      }
-    end
-
-    private
-
-    def parse_inventory(inventory_data)
-      return unless inventory_data.is_a?(Hash)
-
-      @vars = extract_vars(inventory_data)
-      parse_groups(inventory_data)
-      parse_hosts(inventory_data)
-      apply_group_variables
-    end
-
-    def extract_vars(data)
-      data['vars'] || data[:vars] || {}
-    end
-
-    def parse_groups(inventory_data)
-      groups_data = inventory_data['groups'] || inventory_data[:groups] || {}
-
-      groups_data.each do |group_name, group_config|
-        process_group(group_name.to_s, group_config || {})
-      end
-
-      resolve_group_children
-    end
-
-    def process_group(group_name, group_config)
-      @groups[group_name] = {
-        hosts: extract_group_hosts(group_config),
-        vars: extract_group_vars(group_config),
-        children: extract_group_children(group_config)
-      }
-    end
-
-    def extract_group_hosts(config)
-      Array(config['hosts'] || config[:hosts] || [])
-    end
-
-    def extract_group_vars(config)
-      config['vars'] || config[:vars] || {}
-    end
-
-    def extract_group_children(config)
-      Array(config['children'] || config[:children] || [])
-    end
-
-    def parse_hosts(inventory_data)
-      hosts_data = inventory_data['hosts'] || inventory_data[:hosts] || {}
-
-      hosts_data.each do |hostname, host_config|
-        process_host(hostname, host_config || {})
-      end
-    end
-
-    def process_host(hostname, host_config)
-      host_groups = find_host_groups(hostname)
-      host_roles = Array(host_config['roles'] || host_config[:roles] || host_groups)
-
-      @hosts[hostname] = create_host(hostname, host_config, host_roles)
-    end
-
-    def create_host(hostname, config, roles)
-      Host.new(
-        hostname,
-        user: config['user'] || config[:user],
-        port: config['port'] || config[:port],
-        ssh_options: parse_ssh_options(config),
-        roles: roles,
-        vars: config['vars'] || config[:vars] || {}
-      )
-    end
-
-    def parse_ssh_options(host_config)
-      ssh_config = host_config['ssh'] || host_config[:ssh] || {}
-      options = {}
-
-      process_ssh_key_options(ssh_config, options)
-      process_ssh_auth_options(ssh_config, options)
-      process_ssh_verification_options(ssh_config, options)
-      process_ssh_timeout_option(ssh_config, options)
-
-      options
-    end
-
-    def process_ssh_key_options(ssh_config, options)
-      if ssh_config['key_file'] || ssh_config[:key_file]
-        key_file = ssh_config['key_file'] || ssh_config[:key_file]
-        options[:keys] = [File.expand_path(key_file)]
-      end
-
-      return unless ssh_config['key_data'] || ssh_config[:key_data]
-
-      options[:key_data] = Array(ssh_config['key_data'] || ssh_config[:key_data])
-    end
-
-    def process_ssh_auth_options(ssh_config, options)
-      options[:password] = ssh_config['password'] || ssh_config[:password] if ssh_config['password'] || ssh_config[:password]
-      return unless ssh_config['passphrase'] || ssh_config[:passphrase]
-
-      options[:passphrase] = ssh_config['passphrase'] || ssh_config[:passphrase]
-    end
-
-    def process_ssh_verification_options(ssh_config, options)
-      return unless ssh_config.key?('verify_host_key') || ssh_config.key?(:verify_host_key)
-
-      verify_host_key = ssh_config['verify_host_key'] || ssh_config[:verify_host_key]
-      options[:verify_host_key] = verify_host_key ? :always : :never
-    end
-
-    def process_ssh_timeout_option(ssh_config, options)
-      options[:timeout] = ssh_config['timeout'] || ssh_config[:timeout] if ssh_config['timeout'] || ssh_config[:timeout]
-    end
-
-    def find_host_groups(hostname)
-      @groups.each_with_object([]) do |(group_name, group_config), groups|
-        groups << group_name if group_config[:hosts].include?(hostname)
-      end
-    end
-
-    def resolve_group_children
-      @groups.each do |group_name, group_config|
-        process_group_children(group_name, group_config)
-      end
-    end
-
-    def process_group_children(group_name, group_config)
-      group_config[:children].each do |child_group|
-        next unless @groups[child_group]
-
-        @groups[group_name][:hosts].concat(@groups[child_group][:hosts])
-      end
-
-      @groups[group_name][:hosts].uniq!
-    end
-
-    def apply_group_variables
-      @hosts.each do |hostname, host|
-        host_groups = find_host_groups(hostname)
-        apply_group_vars_to_host(host, host_groups)
-        apply_global_vars_to_host(host)
-      end
-    end
-
-    def apply_group_vars_to_host(host, host_groups)
-      host_groups.each do |group_name|
-        group_vars = @groups[group_name][:vars] || {}
-        group_vars.each do |key, value|
-          host.set_var(key, value) unless host.var(key)
-        end
-      end
-    end
-
-    def apply_global_vars_to_host(host)
-      @vars.each do |key, value|
-        host.set_var(key, value) unless host.var(key)
-      end
-    end
-  end
-end

data/lib/kdeploy/logger.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Kdeploy
-  # Custom logger class for Kdeploy with colorized output
-  class KdeployLogger
-    class << self
-      attr_accessor :instance
-
-      # Set up logger instance with specified level and output file
-      # @param level [Symbol] Log level (:debug, :info, :warn, :error, :fatal)
-      # @param file [String, IO] Output file or IO stream
-      # @return [KdeployLogger] Logger instance
-      def setup(level: :info, file: nil)
-        @instance = new(level: level, file: file)
-      end
-
-      def method_missing(method_name, ...)
-        return super unless respond_to_missing?(method_name, false)
-
-        @instance ||= new
-        @instance.send(method_name, ...)
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        return true if %i[debug info warn error fatal].include?(method_name)
-
-        super
-      end
-    end
-
-    # Initialize logger with specified level and output file
-    # @param level [Symbol] Log level (:debug, :info, :warn, :error, :fatal)
-    # @param file [String, IO] Output file or IO stream
-    def initialize(level: :info, file: nil)
-      @logger = Logger.new(file || $stdout)
-      @logger.level = logger_level(level)
-      @logger.formatter = method(:format_message)
-    end
-
-    # Log debug message
-    # @param message [String] Message to log
-    def debug(message)
-      @logger.debug(message)
-    end
-
-    # Log info message
-    # @param message [String] Message to log
-    def info(message)
-      @logger.info(message)
-    end
-
-    # Log warning message
-    # @param message [String] Message to log
-    def warn(message)
-      @logger.warn(message)
-    end
-
-    # Log error message
-    # @param message [String] Message to log
-    def error(message)
-      @logger.error(message)
-    end
-
-    # Log fatal message
-    # @param message [String] Message to log
-    def fatal(message)
-      @logger.fatal(message)
-    end
-
-    private
-
-    def format_message(severity, datetime, _progname, msg)
-      timestamp = datetime.strftime('%Y-%m-%d %H:%M:%S')
-      colored_msg = colorize_message(severity, msg)
-      "[#{timestamp}] #{severity}: #{colored_msg}\n"
-    end
-
-    def logger_level(level)
-      case level.to_sym
-      when :debug then Logger::DEBUG
-      when :info then Logger::INFO
-      when :warn then Logger::WARN
-      when :error then Logger::ERROR
-      when :fatal then Logger::FATAL
-      else Logger::INFO
-      end
-    end
-
-    def colorize_message(severity, message)
-      case severity
-      when 'DEBUG' then message.colorize(:light_black)
-      when 'INFO' then message.colorize(:green)
-      when 'WARN' then message.colorize(:yellow)
-      when 'ERROR' then message.colorize(:red)
-      when 'FATAL' then message.colorize(:light_red)
-      else message
-      end
-    end
-  end
-end