kdeploy 0.1.0

data/lib/kdeploy/inventory.rb

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

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

data/lib/kdeploy/pipeline.rb

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