kdeploy 1.1.9 → 1.2.1

data/exe/kdeploy

@@ -2,17 +2,17 @@
 # frozen_string_literal: true
 
 # 自动修复常见 gem 扩展
-%w[debug rbs].zip(%w[1.7.1 2.8.2]).each do |gem_name, version|
-  require gem_name
-rescue LoadError
-  warn "[Kdeploy] 自动修复 #{gem_name}-#{version} ..."
-  system("gem pristine #{gem_name} --version #{version}")
-  begin
-    require gem_name
-  rescue LoadError
-    warn "[Kdeploy] 依然无法加载 #{gem_name}-#{version}，请手动修复。"
-  end
-end
+# %w[debug rbs].zip(%w[1.7.1 2.8.2]).each do |gem_name, version|
+#   require gem_name
+# rescue LoadError
+#   warn "[Kdeploy] 自动修复 #{gem_name}-#{version} ..."
+#   system("gem pristine #{gem_name} --version #{version}")
+#   begin
+#     require gem_name
+#   rescue LoadError
+#     warn "[Kdeploy] 依然无法加载 #{gem_name}-#{version}，请手动修复。"
+#   end
+# end
 
 require 'kdeploy'
 

data/lib/kdeploy/banner.rb

@@ -3,11 +3,12 @@
 require 'pastel'
 
 module Kdeploy
+  # Banner display module for CLI output
   module Banner
     class << self
       def show
         pastel = Pastel.new
-        <<~BANNER.freeze
+        <<~BANNER
           #{pastel.bright_blue(ASCII_LOGO)}
 
           #{pastel.bright_yellow('⚡')} #{pastel.bright_white('Lightweight Agentless Deployment Tool')}

data/lib/kdeploy/cli.rb

@@ -7,6 +7,7 @@ require 'tty-box'
 require 'fileutils'
 
 module Kdeploy
+  # Command-line interface for Kdeploy
   class CLI < Thor
     extend DSL
 
@@ -108,7 +109,8 @@ module Kdeploy
           next
         end
 
-        runner = Runner.new(hosts, self.class.kdeploy_tasks, parallel: options[:parallel])
+        output = ConsoleOutput.new
+        runner = Runner.new(hosts, self.class.kdeploy_tasks, parallel: options[:parallel], output: output)
         results = runner.run(task)
         print_results(results, task)
       end
@@ -127,6 +129,10 @@ module Kdeploy
 
       # 用 instance_eval 并传递顶层 binding，兼容 heredoc
       self.class.module_eval(File.read(file), file)
+    rescue StandardError => e
+      raise FileNotFoundError, file if e.message.include?('not found')
+
+      raise
     end
 
     def filter_hosts(limit, task_hosts)
@@ -199,7 +205,7 @@ module Kdeploy
                 next if shown[key]
 
                 shown[key] = true
-                duration_str = step[:duration] ? pastel.dim(" [#{'%.2f' % step[:duration]}s]") : ''
+                duration_str = step[:duration] ? pastel.dim(" [#{format('%.2f', step[:duration])}s]") : ''
                 puts pastel.green("    [upload] #{step[:command].sub('upload: ', '')}#{duration_str}")
               end
             when :upload_template
@@ -209,7 +215,7 @@ module Kdeploy
                 next if shown[key]
 
                 shown[key] = true
-                duration_str = step[:duration] ? pastel.dim(" [#{'%.2f' % step[:duration]}s]") : ''
+                duration_str = step[:duration] ? pastel.dim(" [#{format('%.2f', step[:duration])}s]") : ''
                 puts pastel.yellow("    [template] #{step[:command].sub('upload_template: ', '')}#{duration_str}")
               end
             when :run
@@ -219,7 +225,7 @@ module Kdeploy
                 next if shown[key]
 
                 shown[key] = true
-                duration_str = step[:duration] ? pastel.dim(" [#{'%.2f' % step[:duration]}s]") : ''
+                duration_str = step[:duration] ? pastel.dim(" [#{format('%.2f', step[:duration])}s]") : ''
                 puts pastel.cyan("    [run]    #{step[:command].to_s.lines.first.strip}#{duration_str}")
                 # 多行命令内容高亮
                 cmd_lines = step[:command].to_s.lines[1..].map(&:strip).reject(&:empty?)

data/lib/kdeploy/command_executor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  # Executes a single command and records execution time
+  class CommandExecutor
+    def initialize(executor, output)
+      @executor = executor
+      @output = output
+    end
+
+    def execute_run(command, host_name)
+      show_command_header(host_name, :run, command[:command])
+      result, duration = measure_time do
+        @executor.execute(command[:command])
+      end
+      show_command_output(result)
+      { command: command[:command], output: result, duration: duration, type: :run }
+    end
+
+    def execute_upload(command, host_name)
+      show_command_header(host_name, :upload, "#{command[:source]} -> #{command[:destination]}")
+      _result, duration = measure_time do
+        @executor.upload(command[:source], command[:destination])
+      end
+      {
+        command: "upload: #{command[:source]} -> #{command[:destination]}",
+        duration: duration,
+        type: :upload
+      }
+    end
+
+    def execute_upload_template(command, host_name)
+      show_command_header(host_name, :upload_template, "#{command[:source]} -> #{command[:destination]}")
+      _result, duration = measure_time do
+        @executor.upload_template(command[:source], command[:destination], command[:variables])
+      end
+      {
+        command: "upload_template: #{command[:source]} -> #{command[:destination]}",
+        duration: duration,
+        type: :upload_template
+      }
+    end
+
+    private
+
+    def measure_time
+      start_time = Time.now
+      result = yield
+      duration = Time.now - start_time
+      [result, duration]
+    end
+
+    def show_command_output(output)
+      return unless output.is_a?(Hash)
+
+      pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+
+      if output[:stdout] && !output[:stdout].empty?
+        output[:stdout].each_line do |line|
+          @output.write_line("    #{line.rstrip}") unless line.strip.empty?
+        end
+      end
+
+      return unless output[:stderr] && !output[:stderr].empty?
+
+      output[:stderr].each_line do |line|
+        @output.write_line(pastel.green("    #{line.rstrip}")) unless line.strip.empty?
+      end
+    end
+
+    def show_command_header(host_name, type, description)
+      pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+      @output.write_line(pastel.bright_white("\n#{host_name.ljust(24)} : "))
+
+      case type
+      when :run
+        @output.write_line(pastel.cyan("  [run]    #{description.lines.first.strip}"))
+        description.lines[1..].each do |line|
+          @output.write_line("           > #{line.strip}") unless line.strip.empty?
+        end
+      when :upload
+        @output.write_line(pastel.green("  [upload] #{description}"))
+      when :upload_template
+        @output.write_line(pastel.yellow("  [template] #{description}"))
+      end
+    end
+  end
+end

data/lib/kdeploy/command_grouper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  # Groups commands by type and generates task descriptions
+  class CommandGrouper
+    def self.group(commands)
+      commands.group_by do |cmd|
+        group_key_for(cmd)
+      end
+    end
+
+    def self.group_key_for(cmd)
+      case cmd[:type]
+      when :upload, :upload_template
+        "#{cmd[:type]}_#{cmd[:source]}"
+      when :run
+        "#{cmd[:type]}_#{cmd[:command].to_s.lines.first.strip}"
+      else
+        cmd[:type].to_s
+      end
+    end
+
+    def self.task_description(command)
+      case command[:type]
+      when :upload
+        "upload #{command[:source]}"
+      when :upload_template
+        "template #{command[:source]}"
+      when :run
+        command[:command].to_s.lines.first.strip
+      else
+        command[:type].to_s
+      end
+    end
+  end
+end

data/lib/kdeploy/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  # Configuration management for Kdeploy
+  class Configuration
+    DEFAULT_PARALLEL = 10
+    DEFAULT_SSH_TIMEOUT = 30
+    DEFAULT_VERIFY_HOST_KEY = :never
+
+    class << self
+      attr_accessor :default_parallel,
+                    :default_ssh_timeout,
+                    :default_verify_host_key
+
+      def reset
+        @default_parallel = DEFAULT_PARALLEL
+        @default_ssh_timeout = DEFAULT_SSH_TIMEOUT
+        @default_verify_host_key = DEFAULT_VERIFY_HOST_KEY
+      end
+    end
+
+    # Initialize with defaults
+    reset
+  end
+end

data/lib/kdeploy/dsl.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Kdeploy
   module DSL
     def self.extended(base)
@@ -68,8 +70,8 @@ module Kdeploy
       }
     end
 
-    def inventory(&)
-      instance_eval(&) if block_given?
+    def inventory(&block)
+      instance_eval(&block) if block_given?
     end
 
     def get_task_hosts(task_name)

data/lib/kdeploy/errors.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  # Base error class for all Kdeploy errors
+  class Error < StandardError; end
+
+  # Raised when a task is not found
+  class TaskNotFoundError < Error
+    def initialize(task_name)
+      super("Task not found: #{task_name}")
+    end
+  end
+
+  # Raised when a host is not found
+  class HostNotFoundError < Error
+    def initialize(host_name)
+      super("Host not found: #{host_name}")
+    end
+  end
+
+  # Raised when SSH operation fails
+  class SSHError < Error
+    def initialize(message, original_error = nil)
+      super("SSH operation failed: #{message}")
+      @original_error = original_error
+    end
+
+    attr_reader :original_error
+  end
+
+  # Raised when SCP operation fails
+  class SCPError < Error
+    def initialize(message, original_error = nil)
+      super("SCP upload failed: #{message}")
+      @original_error = original_error
+    end
+
+    attr_reader :original_error
+  end
+
+  # Raised when template operation fails
+  class TemplateError < Error
+    def initialize(message, original_error = nil)
+      super("Template operation failed: #{message}")
+      @original_error = original_error
+    end
+
+    attr_reader :original_error
+  end
+
+  # Raised when configuration is invalid
+  class ConfigurationError < Error
+    def initialize(message)
+      super("Configuration error: #{message}")
+    end
+  end
+
+  # Raised when file operation fails
+  class FileNotFoundError < Error
+    def initialize(file_path)
+      super("File not found: #{file_path}")
+    end
+  end
+end

data/lib/kdeploy/executor.rb

@@ -4,6 +4,7 @@ require 'net/ssh'
 require 'net/scp'
 
 module Kdeploy
+  # SSH/SCP executor for remote command execution and file operations
   class Executor
     def initialize(host_config)
       @host = host_config[:name]
@@ -21,7 +22,7 @@ module Kdeploy
 
         ssh.open_channel do |channel|
           channel.exec(command) do |_ch, success|
-            raise "Could not execute command: #{command}" unless success
+            raise SSHError, "Could not execute command: #{command}" unless success
 
             channel.on_data do |_ch, data|
               stdout << data
@@ -40,9 +41,9 @@ module Kdeploy
         }
       end
     rescue Net::SSH::AuthenticationFailed => e
-      raise "SSH authentication failed: #{e.message}"
+      raise SSHError.new("SSH authentication failed: #{e.message}", e)
     rescue StandardError => e
-      raise "SSH execution failed: #{e.message}"
+      raise SSHError.new("SSH execution failed: #{e.message}", e)
     end
 
     def upload(source, destination)
@@ -50,13 +51,13 @@ module Kdeploy
         scp.upload!(source, destination)
       end
     rescue StandardError => e
-      raise "SCP upload failed: #{e.message}"
+      raise SCPError.new("SCP upload failed: #{e.message}", e)
     end
 
     def upload_template(source, destination, variables = {})
       Template.render_and_upload(self, source, destination, variables)
     rescue StandardError => e
-      raise "Template upload failed: #{e.message}"
+      raise TemplateError.new("Template upload failed: #{e.message}", e)
     end
 
     private

data/lib/kdeploy/initializer.rb

@@ -3,6 +3,7 @@
 require 'fileutils'
 
 module Kdeploy
+  # Project initializer for creating new deployment projects
   class Initializer
     def initialize(target_dir = '.')
       @target_dir = File.expand_path(target_dir)

data/lib/kdeploy/output.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'pastel'
+
+module Kdeploy
+  # Abstract output interface
+  class Output
+    def write(message)
+      raise NotImplementedError, 'Subclasses must implement write'
+    end
+
+    def write_line(message)
+      write("#{message}\n")
+    end
+
+    def write_error(message)
+      write_line(message)
+    end
+  end
+
+  # Console output implementation
+  class ConsoleOutput < Output
+    def initialize
+      @pastel = Pastel.new
+    end
+
+    def write(message)
+      print(message)
+    end
+
+    def write_line(message)
+      puts(message)
+    end
+
+    def write_error(message)
+      puts(@pastel.red(message))
+    end
+
+    attr_reader :pastel
+  end
+
+  # Silent output for testing
+  class SilentOutput < Output
+    attr_reader :messages, :errors
+
+    def initialize
+      @messages = []
+      @errors = []
+    end
+
+    def write(message)
+      @messages << message
+    end
+
+    def write_line(message)
+      @messages << "#{message}\n"
+    end
+
+    def write_error(message)
+      @errors << message
+      @messages << "#{message}\n"
+    end
+
+    def clear
+      @messages.clear
+      @errors.clear
+    end
+  end
+end

data/lib/kdeploy/post_install.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Kdeploy
+  # Post-installation configuration handler
   class PostInstall
     class << self
       def run

data/lib/kdeploy/runner.rb

@@ -3,90 +3,24 @@
 require 'concurrent'
 
 module Kdeploy
+  # Concurrent task runner for executing tasks across multiple hosts
   class Runner
-    def initialize(hosts, tasks, parallel: 10)
+    def initialize(hosts, tasks, parallel: Configuration.default_parallel, output: ConsoleOutput.new)
       @hosts = hosts
       @tasks = tasks
       @parallel = parallel
+      @output = output
       @pool = Concurrent::FixedThreadPool.new(@parallel)
       @results = Concurrent::Hash.new
     end
 
     def run(task_name)
       task = @tasks[task_name]
-      raise "Task not found: #{task_name}" unless task
+      raise TaskNotFoundError, task_name unless task
 
       futures = @hosts.map do |name, config|
         Concurrent::Future.execute(executor: @pool) do
-          executor = Executor.new(config)
-          result = { status: :success, output: [] }
-
-          task[:block].call.group_by do |cmd|
-            cmd[:type].to_s + (if cmd[:type] == :upload
-                                 cmd[:source].to_s
-                               else
-                                 cmd[:type] == :run ? cmd[:command].to_s.lines.first.strip : ''
-                               end)
-          end.each_value do |commands|
-            # 生成 TASK 横幅
-            pastel = Pastel.new
-            first_cmd = commands.first
-            task_desc = case first_cmd[:type]
-                        when :upload
-                          "upload #{first_cmd[:source]}"
-                        when :upload_template
-                          "template #{first_cmd[:source]}"
-                        when :run
-                          first_cmd[:command].to_s.lines.first.strip
-                        else
-                          first_cmd[:type].to_s
-                        end
-            puts pastel.cyan("\nTASK [#{task_desc}] " + ('*' * 64))
-            commands.each do |command|
-              case command[:type]
-              when :run
-                pastel = Pastel.new
-                puts pastel.bright_white("\n#{name.ljust(24)} : ")
-                puts pastel.cyan("  [run]    #{command[:command].lines.first.strip}")
-                command[:command].lines[1..].each { |line| puts "           > #{line.strip}" unless line.strip.empty? }
-                t1 = Time.now
-                output = executor.execute(command[:command])
-                t2 = Time.now
-                duration = t2 - t1
-                # 统一输出命令结果
-                if output[:stdout] && !output[:stdout].empty?
-                  output[:stdout].each_line { |line| puts "    #{line.rstrip}" unless line.strip.empty? }
-                end
-                if output[:stderr] && !output[:stderr].empty?
-                  output[:stderr].each_line { |line| puts pastel.green("    #{line.rstrip}") unless line.strip.empty? }
-                end
-                result[:output] << { command: command[:command], output: output, duration: duration, type: :run }
-              when :upload
-                pastel = Pastel.new
-                puts pastel.bright_white("\n#{name.ljust(24)} : ")
-                puts pastel.green("  [upload] #{command[:source]} -> #{command[:destination]}")
-                t1 = Time.now
-                executor.upload(command[:source], command[:destination])
-                t2 = Time.now
-                duration = t2 - t1
-                result[:output] << { command: "upload: #{command[:source]} -> #{command[:destination]}", duration: duration, type: :upload }
-              when :upload_template
-                pastel = Pastel.new
-                puts pastel.bright_white("\n#{name.ljust(24)} : ")
-                puts pastel.yellow("  [template] #{command[:source]} -> #{command[:destination]}")
-                t1 = Time.now
-                executor.upload_template(command[:source], command[:destination], command[:vars])
-                t2 = Time.now
-                duration = t2 - t1
-                result[:output] << { command: "upload_template: #{command[:source]} -> #{command[:destination]}", duration: duration,
-                                     type: :upload_template }
-              end
-            end
-          end
-
-          @results[name] = result
-        rescue StandardError => e
-          @results[name] = { status: :failed, error: e.message }
+          execute_task_for_host(name, config, task)
         end
       end
 
@@ -95,5 +29,49 @@ module Kdeploy
     ensure
       @pool.shutdown
     end
+
+    private
+
+    def execute_task_for_host(name, config, task)
+      executor = Executor.new(config)
+      command_executor = CommandExecutor.new(executor, @output)
+      result = { status: :success, output: [] }
+
+      commands = task[:block].call
+      grouped_commands = CommandGrouper.group(commands)
+
+      grouped_commands.each_value do |command_group|
+        first_cmd = command_group.first
+        task_desc = CommandGrouper.task_description(first_cmd)
+        show_task_header(task_desc)
+
+        command_group.each do |command|
+          step_result = execute_command(command_executor, command, name)
+          result[:output] << step_result
+        end
+      end
+
+      @results[name] = result
+    rescue StandardError => e
+      @results[name] = { status: :failed, error: e.message }
+    end
+
+    def execute_command(command_executor, command, host_name)
+      case command[:type]
+      when :run
+        command_executor.execute_run(command, host_name)
+      when :upload
+        command_executor.execute_upload(command, host_name)
+      when :upload_template
+        command_executor.execute_upload_template(command, host_name)
+      else
+        raise ConfigurationError, "Unknown command type: #{command[:type]}"
+      end
+    end
+
+    def show_task_header(task_desc)
+      pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+      @output.write_line(pastel.cyan("\nTASK [#{task_desc}] " + ('*' * 64)))
+    end
   end
 end

data/lib/kdeploy/template.rb

@@ -5,6 +5,7 @@ require 'ostruct'
 require 'tempfile'
 
 module Kdeploy
+  # ERB template rendering and upload handler
   class Template
     def self.render(template_path, variables = {})
       template_content = File.read(template_path)

data/lib/kdeploy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Kdeploy
-  VERSION = '1.1.9'
+  VERSION = '1.2.1'
 end

data/lib/kdeploy.rb

@@ -1,16 +1,21 @@
 # frozen_string_literal: true
 
 require_relative 'kdeploy/version'
+require_relative 'kdeploy/errors'
+require_relative 'kdeploy/configuration'
+require_relative 'kdeploy/output'
 require_relative 'kdeploy/banner'
 require_relative 'kdeploy/dsl'
 require_relative 'kdeploy/executor'
+require_relative 'kdeploy/command_grouper'
+require_relative 'kdeploy/command_executor'
 require_relative 'kdeploy/runner'
 require_relative 'kdeploy/initializer'
 require_relative 'kdeploy/template'
 require_relative 'kdeploy/post_install'
 require_relative 'kdeploy/cli'
 
+# Kdeploy - A lightweight agentless deployment automation tool
 module Kdeploy
-  class Error < StandardError; end
   # Your code goes here...
 end