kdeploy 1.2.1 → 1.2.2

data/lib/kdeploy/cli.rb

@@ -28,41 +28,7 @@ module Kdeploy
       if command
         super
       else
-        pastel = Pastel.new
-        puts Kdeploy::Banner.show
-        puts <<~HELP
-          #{pastel.bright_white('📖 Available Commands:')}
-
-          #{pastel.bright_yellow('🚀')} #{pastel.bright_white('execute TASK_FILE [TASK]')}     Execute deployment tasks from file
-          #{pastel.dim('    --limit HOSTS')}              Limit to specific hosts (comma-separated)
-          #{pastel.dim('    --parallel NUM')}             Number of parallel executions (default: 5)
-          #{pastel.dim('    --dry-run')}                  Show what would be done without executing
-
-          #{pastel.bright_yellow('🆕')} #{pastel.bright_white('init [DIR]')}                  Initialize new deployment project
-          #{pastel.bright_yellow('ℹ️')} #{pastel.bright_white('version')}                    Show version information
-          #{pastel.bright_yellow('❓')} #{pastel.bright_white('help [COMMAND]')}              Show help information
-
-          #{pastel.bright_white('💡 Examples:')}
-
-          #{pastel.dim('# Initialize a new project')}
-          #{pastel.bright_cyan('kdeploy init my-deployment')}
-
-          #{pastel.dim('# Deploy to web servers')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb deploy_web')}
-
-          #{pastel.dim('# Backup database')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb backup_db')}
-
-          #{pastel.dim('# Run maintenance on specific hosts')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb maintenance --limit web01')}
-
-          #{pastel.dim('# Preview deployment')}
-          #{pastel.bright_cyan('kdeploy execute deploy.rb deploy_web --dry-run')}
-
-          #{pastel.bright_white('📚 Documentation:')}
-          #{pastel.bright_cyan('https://github.com/kevin197011/kdeploy')}
-
-        HELP
+        show_general_help
       end
     end
 
@@ -80,40 +46,11 @@ module Kdeploy
     method_option :parallel, type: :numeric, default: 10, desc: 'Number of parallel executions'
     method_option :dry_run, type: :boolean, desc: 'Show what would be done'
     def execute(task_file, task_name = nil)
-      # 只在最前面输出一次 banner
-      @banner_printed ||= false
-      unless @banner_printed
-        puts Kdeploy::Banner.show
-        @banner_printed = true
-      end
-
+      show_banner_once
       load_task_file(task_file)
 
-      tasks_to_run = if task_name
-                       [task_name.to_sym]
-                     else
-                       self.class.kdeploy_tasks.keys
-                     end
-
-      tasks_to_run.each do |task|
-        task_hosts = self.class.get_task_hosts(task)
-        hosts = filter_hosts(options[:limit], task_hosts)
-
-        if hosts.empty?
-          puts Kdeploy::Banner.show_error("No hosts found for task: #{task}")
-          next
-        end
-
-        if options[:dry_run]
-          print_dry_run(hosts, task)
-          next
-        end
-
-        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
+      tasks_to_run = determine_tasks(task_name)
+      execute_tasks(tasks_to_run)
     rescue StandardError => e
       puts Kdeploy::Banner.show_error(e.message)
       exit 1
@@ -122,11 +59,7 @@ module Kdeploy
     private
 
     def load_task_file(file)
-      unless File.exist?(file)
-        puts Kdeploy::Banner.show_error("Task file not found: #{file}")
-        exit 1
-      end
-
+      validate_task_file(file)
       # 用 instance_eval 并传递顶层 binding，兼容 heredoc
       self.class.module_eval(File.read(file), file)
     rescue StandardError => e
@@ -135,6 +68,19 @@ module Kdeploy
       raise
     end
 
+    def validate_task_file(file)
+      return if File.exist?(file)
+
+      puts Kdeploy::Banner.show_error("Task file not found: #{file}")
+      exit 1
+    end
+
+    def show_general_help
+      formatter = HelpFormatter.new
+      puts Kdeploy::Banner.show
+      puts formatter.format_help
+    end
+
     def filter_hosts(limit, task_hosts)
       hosts = self.class.kdeploy_hosts.slice(*task_hosts)
       return hosts unless limit
@@ -144,139 +90,137 @@ module Kdeploy
     end
 
     def print_dry_run(hosts, task_name)
+      formatter = OutputFormatter.new
       puts Kdeploy::Banner.show
-      pastel = Pastel.new
-      puts TTY::Box.frame(
-        'Showing what would be done without executing any commands',
-        title: { top_left: ' Dry Run Mode ', bottom_right: ' Kdeploy ' },
-        style: {
-          border: {
-            fg: :blue
-          }
-        }
-      )
+      puts formatter.format_dry_run_header
       puts
 
       hosts.each do |name, config|
-        commands = self.class.kdeploy_tasks[task_name][:block].call
-        output = commands.map do |command|
-          case command[:type]
-          when :run
-            "#{pastel.green('>')} #{command[:command]}"
-          when :upload
-            "#{pastel.blue('>')} Upload: #{command[:source]} -> #{command[:destination]}"
-          end
-        end.join("\n")
-
-        puts TTY::Box.frame(
-          output,
-          title: { top_left: " #{name} (#{config[:ip]}) " },
-          style: {
-            border: {
-              fg: :yellow
-            }
-          }
-        )
-        puts
+        print_dry_run_for_host(name, config, task_name, formatter)
       end
     end
 
+    def print_dry_run_for_host(name, config, task_name, formatter)
+      commands = self.class.kdeploy_tasks[task_name][:block].call
+      output = commands.map { |cmd| formatter.format_command_for_dry_run(cmd) }.join("\n")
+      title = "#{name} (#{config[:ip]})"
+      puts formatter.format_dry_run_box(title, output)
+      puts
+    end
+
     def print_results(results, task_name)
-      pastel = Pastel.new
-      puts pastel.cyan("\nPLAY [#{task_name}] " + ('*' * 64))
+      formatter = OutputFormatter.new
+      puts formatter.format_task_header(task_name)
 
       results.each do |host, result|
-        status = case result[:status]
-                 when :success then pastel.green('ok')
-                 when :changed then pastel.yellow('changed')
-                 else pastel.red('failed')
-                 end
-        puts pastel.bright_white("\n#{host.ljust(24)} : #{status}")
-
-        if %i[success changed].include?(result[:status])
-          shown = {}
-          grouped = result[:output].group_by { |step| step[:type] || :run }
-          grouped.each do |type, steps|
-            case type
-            when :upload
-              puts pastel.green('  === Upload ===')
-              steps.each do |step|
-                key = [step[:command], type].hash
-                next if shown[key]
-
-                shown[key] = true
-                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
-              puts pastel.yellow('  === Template ===')
-              steps.each do |step|
-                key = [step[:command], type].hash
-                next if shown[key]
-
-                shown[key] = true
-                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
-              puts pastel.cyan('  === Run ===')
-              steps.each do |step|
-                key = [step[:command], type].hash
-                next if shown[key]
-
-                shown[key] = true
-                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?)
-                cmd_lines.each { |line| puts pastel.cyan("           > #{line}") } if cmd_lines.any?
-                if step[:output].is_a?(Hash) && step[:output][:stdout]
-                  step[:output][:stdout].each_line do |line|
-                    puts pastel.green("        #{line.rstrip}") unless line.strip.empty?
-                  end
-                elsif step[:output].is_a?(String)
-                  step[:output].each_line do |line|
-                    puts pastel.green("        #{line.rstrip}") unless line.strip.empty?
-                  end
-                end
-              end
-            end
-          end
-        else
-          # 失败主机高亮错误
-          err = result[:error] || (if result[:output].is_a?(Array)
-                                     result[:output].map do |o|
-                                       o[:output][:stderr] if o[:output].is_a?(Hash)
-                                     end.compact.join("\n")
-                                   else
-                                     result[:output].to_s
-                                   end)
-          puts pastel.red("  ERROR: #{err}")
-        end
+        puts formatter.format_host_status(host, result[:status])
+        print_host_result(host, result, formatter)
+      end
+
+      print_summary(results, formatter)
+    end
+
+    def print_host_result(_host, result, formatter)
+      if %i[success changed].include?(result[:status])
+        print_success_result(result, formatter)
+      else
+        print_failure_result(result, formatter)
+      end
+    end
+
+    def print_success_result(result, formatter)
+      shown = {}
+      grouped = group_output_by_type(result[:output])
+
+      grouped.each do |type, steps|
+        output_lines = format_steps_by_type(type, steps, shown, formatter)
+        output_lines.each { |line| puts line }
       end
+    end
+
+    def group_output_by_type(output)
+      output.group_by { |step| step[:type] || :run }
+    end
+
+    def format_steps_by_type(type, steps, shown, formatter)
+      case type
+      when :upload
+        formatter.format_upload_steps(steps, shown)
+      when :upload_template
+        formatter.format_template_steps(steps, shown)
+      when :run
+        formatter.format_run_steps(steps, shown)
+      else
+        []
+      end
+    end
+
+    def print_failure_result(result, formatter)
+      error_message = extract_error_message(result)
+      puts formatter.format_error(error_message)
+    end
 
-      # summary
-      puts pastel.cyan("\nPLAY RECAP #{'*' * 64}")
+    def print_summary(results, formatter)
+      puts formatter.format_summary_header
       max_host_len = results.keys.map(&:length).max || 16
-      ok_w = 7
-      changed_w = 11
-      failed_w = 10
+
       results.keys.sort.each do |host|
         result = results[host]
-        ok = %i[success changed].include?(result[:status]) ? result[:output].size : 0
-        failed = result[:status] == :failed ? 1 : 0
-        changed = result[:status] == :changed ? result[:output].size : 0
-        ok_str = pastel.green("ok=#{ok.to_s.ljust(ok_w - 3)}")
-        changed_str = pastel.yellow("changed=#{changed.to_s.ljust(changed_w - 8)}")
-        failed_str = pastel.red("failed=#{failed.to_s.ljust(failed_w - 7)}")
-        line = "#{host.ljust(max_host_len)} : #{ok_str}  #{changed_str}  #{failed_str}"
-        if failed.positive?
-          puts pastel.red(line)
-        elsif ok.positive? && failed.zero?
-          puts pastel.green(line)
-        else
-          puts line
-        end
+        puts formatter.format_summary_line(host, result, max_host_len)
+      end
+    end
+
+    def show_banner_once
+      @banner_printed ||= false
+      return if @banner_printed
+
+      puts Kdeploy::Banner.show
+      @banner_printed = true
+    end
+
+    def determine_tasks(task_name)
+      task_name ? [task_name.to_sym] : self.class.kdeploy_tasks.keys
+    end
+
+    def execute_tasks(tasks_to_run)
+      tasks_to_run.each do |task|
+        execute_single_task(task)
+      end
+    end
+
+    def execute_single_task(task)
+      task_hosts = self.class.get_task_hosts(task)
+      hosts = filter_hosts(options[:limit], task_hosts)
+
+      if hosts.empty?
+        puts Kdeploy::Banner.show_error("No hosts found for task: #{task}")
+        return
+      end
+
+      if options[:dry_run]
+        print_dry_run(hosts, task)
+        return
+      end
+
+      run_task(hosts, task)
+    end
+
+    def run_task(hosts, task)
+      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
+
+    def extract_error_message(result)
+      return result[:error] if result[:error]
+
+      if result[:output].is_a?(Array)
+        result[:output].map do |o|
+          o[:output][:stderr] if o[:output].is_a?(Hash)
+        end.compact.join("\n")
+      else
+        result[:output].to_s
       end
     end
   end

data/lib/kdeploy/command_executor.rb

@@ -54,35 +54,52 @@ module Kdeploy
       return unless output.is_a?(Hash)
 
       pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+      show_stdout(output[:stdout])
+      show_stderr(output[:stderr], pastel)
+    end
+
+    def show_stdout(stdout)
+      return unless stdout && !stdout.empty?
 
-      if output[:stdout] && !output[:stdout].empty?
-        output[:stdout].each_line do |line|
-          @output.write_line("    #{line.rstrip}") unless line.strip.empty?
-        end
+      stdout.each_line do |line|
+        @output.write_line("    #{line.rstrip}") unless line.strip.empty?
       end
+    end
 
-      return unless output[:stderr] && !output[:stderr].empty?
+    def show_stderr(stderr, pastel)
+      return unless stderr && !stderr.empty?
 
-      output[:stderr].each_line do |line|
+      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
+      pastel = get_pastel
       @output.write_line(pastel.bright_white("\n#{host_name.ljust(24)} : "))
+      format_command_by_type(type, description, pastel)
+    end
 
+    def get_pastel
+      @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
+    end
+
+    def format_command_by_type(type, description, pastel)
       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
+        format_run_command(description, pastel)
       when :upload
         @output.write_line(pastel.green("  [upload] #{description}"))
       when :upload_template
         @output.write_line(pastel.yellow("  [template] #{description}"))
       end
     end
+
+    def format_run_command(description, pastel)
+      @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
+    end
   end
 end

data/lib/kdeploy/dsl.rb

@@ -3,6 +3,7 @@
 require 'set'
 
 module Kdeploy
+  # Domain-specific language for defining hosts, roles, and tasks
   module DSL
     def self.extended(base)
       base.instance_variable_set(:@kdeploy_hosts, {})
@@ -32,21 +33,31 @@ module Kdeploy
 
     def task(name, on: nil, roles: nil, &block)
       kdeploy_tasks[name] = {
-        hosts: if on.is_a?(Array)
-                 on
-               else
-                 (on ? [on] : nil)
-               end,
-        roles: if roles.is_a?(Array)
-                 roles
-               else
-                 (roles ? [roles] : nil)
-               end,
-        block: lambda {
-          @kdeploy_commands = []
-          instance_eval(&block)
-          @kdeploy_commands
-        }
+        hosts: normalize_hosts_option(on),
+        roles: normalize_roles_option(roles),
+        block: create_task_block(block)
+      }
+    end
+
+    def normalize_hosts_option(on)
+      return on if on.is_a?(Array)
+      return [on] if on
+
+      nil
+    end
+
+    def normalize_roles_option(roles)
+      return roles if roles.is_a?(Array)
+      return [roles] if roles
+
+      nil
+    end
+
+    def create_task_block(block)
+      lambda {
+        @kdeploy_commands = []
+        instance_eval(&block)
+        @kdeploy_commands
       }
     end
 
@@ -76,25 +87,33 @@ module Kdeploy
 
     def get_task_hosts(task_name)
       task = kdeploy_tasks[task_name]
-      return kdeploy_hosts.keys if !task || (!task[:hosts] && !task[:roles])
+      return kdeploy_hosts.keys if task_empty?(task)
 
       hosts = Set.new
+      add_explicit_hosts(task, hosts)
+      add_role_hosts(task, hosts)
+      hosts.to_a
+    end
+
+    def task_empty?(task)
+      !task || (!task[:hosts] && !task[:roles])
+    end
 
-      # 添加指定的主机
+    def add_explicit_hosts(task, hosts)
       task[:hosts]&.each do |host|
         hosts.add(host) if kdeploy_hosts.key?(host)
       end
+    end
 
-      # 添加角色中的主机
+    def add_role_hosts(task, hosts)
       task[:roles]&.each do |role|
-        next unless (role_hosts = kdeploy_roles[role])
+        role_hosts = kdeploy_roles[role]
+        next unless role_hosts
 
         role_hosts.each do |host|
           hosts.add(host) if kdeploy_hosts.key?(host)
         end
       end
-
-      hosts.to_a
     end
   end
 end

data/lib/kdeploy/executor.rb

@@ -17,28 +17,7 @@ module Kdeploy
 
     def execute(command)
       Net::SSH.start(@ip, @user, ssh_options) do |ssh|
-        stdout = String.new
-        stderr = String.new
-
-        ssh.open_channel do |channel|
-          channel.exec(command) do |_ch, success|
-            raise SSHError, "Could not execute command: #{command}" unless success
-
-            channel.on_data do |_ch, data|
-              stdout << data
-            end
-
-            channel.on_extended_data do |_ch, _type, data|
-              stderr << data
-            end
-          end
-        end
-        ssh.loop
-        {
-          stdout: stdout.strip,
-          stderr: stderr.strip,
-          command: command
-        }
+        execute_command_on_ssh(ssh, command)
       end
     rescue Net::SSH::AuthenticationFailed => e
       raise SSHError.new("SSH authentication failed: #{e.message}", e)
@@ -46,6 +25,39 @@ module Kdeploy
       raise SSHError.new("SSH execution failed: #{e.message}", e)
     end
 
+    def execute_command_on_ssh(ssh, command)
+      stdout = String.new
+      stderr = String.new
+
+      ssh.open_channel do |channel|
+        channel.exec(command) do |_ch, success|
+          raise SSHError, "Could not execute command: #{command}" unless success
+
+          setup_channel_handlers(channel, stdout, stderr)
+        end
+      end
+      ssh.loop
+      build_command_result(stdout, stderr, command)
+    end
+
+    def setup_channel_handlers(channel, stdout, stderr)
+      channel.on_data do |_ch, data|
+        stdout << data
+      end
+
+      channel.on_extended_data do |_ch, _type, data|
+        stderr << data
+      end
+    end
+
+    def build_command_result(stdout, stderr, command)
+      {
+        stdout: stdout.strip,
+        stderr: stderr.strip,
+        command: command
+      }
+    end
+
     def upload(source, destination)
       Net::SCP.start(@ip, @user, ssh_options) do |scp|
         scp.upload!(source, destination)
@@ -63,18 +75,29 @@ module Kdeploy
     private
 
     def ssh_options
-      options = {
+      options = base_ssh_options
+      add_authentication(options)
+      add_port_option(options)
+      options
+    end
+
+    def base_ssh_options
+      {
         verify_host_key: :never,
         timeout: 30
       }
+    end
 
+    def add_authentication(options)
       if @password
         options[:password] = @password
       elsif @key
         options[:keys] = [@key]
       end
-      options[:port] = @port if @port # 新增端口传递
-      options
+    end
+
+    def add_port_option(options)
+      options[:port] = @port if @port
     end
   end
 end