kdeploy 1.3.1 → 1.3.4

data/lib/kdeploy/{cli.rb → cli/cli.rb}

@@ -2,6 +2,7 @@
 
 require 'thor'
 require 'json'
+require 'yaml'
 require 'pastel'
 require 'tty-table'
 require 'tty-box'
@@ -53,17 +54,20 @@ module Kdeploy
     method_option :retry_delay, type: :numeric, desc: 'Retry delay seconds (default: 1)'
     method_option :retry_on_nonzero, type: :boolean, desc: 'Retry commands on nonzero exit status (default: false)'
     method_option :timeout, type: :numeric, desc: 'Per-host execution timeout seconds (default: none)'
+    method_option :step_timeout, type: :numeric, desc: 'Per-step execution timeout seconds (default: none)'
+    method_option :retry_policy, type: :string, desc: 'Retry policy JSON to override config file'
+    method_option :retry_policy_file, type: :string, desc: 'Retry policy JSON file to override config file'
     def execute(task_file, task_name = nil)
-      load_config_file
-      show_banner_once
       @task_file_dir = File.dirname(File.expand_path(task_file))
+      Configuration.load_for_execute(task_dir: @task_file_dir)
+      show_banner_once
       load_task_file(task_file)
 
       tasks_to_run = determine_tasks(task_name)
       all_results = execute_tasks(tasks_to_run)
 
-      # Exit non-zero if any executed host failed.
-      exit 1 if any_failed?(all_results)
+      # Exit non-zero if any executed host failed or a task could not run.
+      exit 1 if any_failed?(all_results) || @task_errors
     rescue StandardError => e
       puts Kdeploy::Banner.show_error(e.message)
       exit 1
@@ -72,12 +76,13 @@ module Kdeploy
     private
 
     def load_config_file
-      Configuration.load_from_file
+      # ponytail: kept for compatibility; prefer Configuration.load_for_execute
+      Configuration.load_for_execute(task_dir: @task_file_dir)
     end
 
     def load_task_file(file)
       validate_task_file(file)
-      # 用 instance_eval 并传递顶层 binding，兼容 heredoc
+      # Use module_eval with top-level binding to keep heredoc compatible
       self.class.module_eval(File.read(file), file)
     rescue StandardError => e
       raise FileNotFoundError, file if e.message.include?('not found')
@@ -103,6 +108,8 @@ module Kdeploy
       return hosts unless limit
 
       host_names = limit.split(',').map(&:strip)
+      unknown = host_names.reject { |name| hosts.key?(name) }
+      warn "Warning: --limit ignored unknown host(s): #{unknown.join(', ')}" if unknown.any?
       hosts.slice(*host_names)
     end
 
@@ -145,7 +152,7 @@ module Kdeploy
     end
 
     def print_host_result(host, result, formatter)
-      if %i[success changed].include?(result[:status])
+      if %i[success].include?(result[:status])
         print_success_result(host, result, formatter)
       else
         print_failure_result(host, result, formatter)
@@ -221,19 +228,31 @@ module Kdeploy
     end
 
     def determine_tasks(task_name)
-      task_name ? [task_name.to_sym] : self.class.kdeploy_tasks.keys
+      if task_name
+        sym = task_name.to_sym
+        raise TaskNotFoundError, task_name unless self.class.kdeploy_tasks.key?(sym)
+
+        [sym]
+      else
+        self.class.kdeploy_tasks.keys
+      end
     end
 
     def execute_tasks(tasks_to_run)
       all_results = {}
+      @task_errors = false
+
+      if tasks_to_run.empty?
+        puts Kdeploy::Banner.show_error('No tasks defined in task file')
+        @task_errors = true
+        return all_results
+      end
 
       tasks_to_run.each do |task|
         task_results = execute_single_task(task)
-        # Collect results for final summary
         all_results[task] = task_results if task_results
 
-        # Stop executing remaining tasks once any host failed for this task.
-        break if task_failed?(task_results)
+        break if task_failed?(task_results) || @task_errors
       end
 
       # Show combined summary at the end for all tasks
@@ -248,6 +267,8 @@ module Kdeploy
 
       if hosts.empty?
         puts Kdeploy::Banner.show_error("No hosts found for task: #{task}")
+        puts 'This usually means no hosts matched the task configuration or --limit filter.'
+        @task_errors = true
         return nil
       end
 
@@ -272,6 +293,8 @@ module Kdeploy
       retry_on_nonzero =
         options[:retry_on_nonzero].nil? ? Configuration.default_retry_on_nonzero : options[:retry_on_nonzero]
       host_timeout = options[:timeout].nil? ? Configuration.default_host_timeout : options[:timeout]
+      step_timeout = options[:step_timeout].nil? ? Configuration.default_step_timeout : options[:step_timeout]
+      retry_policy = resolve_retry_policy
       base_dir = @task_file_dir
       runner = Runner.new(
         hosts, self.class.kdeploy_tasks,
@@ -282,7 +305,9 @@ module Kdeploy
         retries: retries,
         retry_delay: retry_delay,
         retry_on_nonzero: retry_on_nonzero,
-        host_timeout: host_timeout
+        host_timeout: host_timeout,
+        step_timeout: step_timeout,
+        retry_policy: retry_policy
       )
       results = runner.run(task)
       if options[:format] == 'json'
@@ -315,10 +340,9 @@ module Kdeploy
       all_hosts = {}
       all_results.each do |task_name, task_results|
         task_results.each do |host, result|
-          all_hosts[host] ||= { ok: 0, changed: 0, failed: 0, tasks: [] }
+          all_hosts[host] ||= { ok: 0, failed: 0, tasks: [] }
           counts = formatter.calculate_summary_counts(result)
           all_hosts[host][:ok] += counts[:ok]
-          all_hosts[host][:changed] += counts[:changed]
           all_hosts[host][:failed] += counts[:failed]
           all_hosts[host][:tasks] << task_name
         end
@@ -370,15 +394,13 @@ module Kdeploy
         duration: step[:duration]
       }
 
-      out[:exit_status] = step[:output][:exit_status] if step[:output].is_a?(Hash) && step[:output].key?(:exit_status)
-
-      out[:result] = step[:result] if step[:type] == :sync
-
-      if options[:debug] && step[:type] == :run && step[:output].is_a?(Hash)
+      if step[:output].is_a?(Hash)
         out[:stdout] = step[:output][:stdout]
         out[:stderr] = step[:output][:stderr]
+        out[:exit_status] = step[:output][:exit_status]
       end
 
+      out[:result] = step[:result] if step[:type] == :sync
       out
     end
 
@@ -397,7 +419,9 @@ module Kdeploy
           destination: cmd[:destination],
           ignore: cmd[:ignore] || [],
           exclude: cmd[:exclude] || [],
-          delete: cmd[:delete] || false
+          delete: cmd[:delete] || false,
+          fast: cmd[:fast],
+          parallel: cmd[:parallel]
         }
       else
         { type: cmd[:type].to_s }
@@ -409,11 +433,61 @@ module Kdeploy
 
       if result[:output].is_a?(Array)
         result[:output].map do |o|
-          o[:output][:stderr] if o[:output].is_a?(Hash)
+          next unless o.is_a?(Hash)
+
+          err = o[:output]
+          next unless err.is_a?(Hash)
+
+          pieces = []
+          pieces << "command=#{err[:command]}" if err[:command]
+          pieces << "exit_status=#{err[:exit_status]}" if err[:exit_status]
+          pieces << "stderr=#{err[:stderr]}" if err[:stderr]
+          pieces.join(' ')
         end.compact.join("\n")
       else
         result[:output].to_s
       end
     end
+
+    def parse_retry_policy(raw)
+      policy = JSON.parse(raw)
+      raise ArgumentError, 'retry_policy must be a JSON object' unless policy.is_a?(Hash)
+
+      policy
+    rescue JSON::ParserError => e
+      raise ArgumentError, "retry_policy JSON parse error: #{e.message}"
+    end
+
+    def resolve_retry_policy
+      if options[:retry_policy_file]
+        path = options[:retry_policy_file]
+        unless File.exist?(path)
+          raise ArgumentError,
+                "retry_policy file not found: #{path} (examples: retry_policy.example.json / retry_policy.example.yml)"
+        end
+
+        return parse_retry_policy_file(path)
+      end
+      return parse_retry_policy(options[:retry_policy]) if options[:retry_policy]
+
+      Configuration.default_retry_policy
+    end
+
+    def parse_retry_policy_file(path)
+      ext = File.extname(path).downcase
+      raw = File.read(path)
+      policy =
+        case ext
+        when '.yml', '.yaml'
+          YAML.safe_load(raw) || {}
+        else
+          JSON.parse(raw)
+        end
+      raise ArgumentError, 'retry_policy must be a JSON/YAML object' unless policy.is_a?(Hash)
+
+      policy
+    rescue JSON::ParserError, Psych::SyntaxError => e
+      raise ArgumentError, "retry_policy parse error: #{e.message}"
+    end
   end
 end

data/lib/kdeploy/{help_formatter.rb → cli/help_formatter.rb}

@@ -36,6 +36,9 @@ module Kdeploy
         #{@pastel.dim('    --retry-delay SECONDS')}      Retry delay seconds (default: 1; overridden by .kdeploy.yml)
         #{@pastel.dim('    --retry-on-nonzero')}         Retry commands on nonzero exit status (default: false; overridden by .kdeploy.yml)
         #{@pastel.dim('    --timeout SECONDS')}          Per-host execution timeout seconds (default: none; overridden by .kdeploy.yml)
+        #{@pastel.dim('    --step-timeout SECONDS')}     Per-step execution timeout seconds (default: none; overridden by .kdeploy.yml)
+        #{@pastel.dim('    --retry-policy JSON')}        Retry policy JSON (overrides .kdeploy.yml)
+        #{@pastel.dim('    --retry-policy-file PATH')}   Retry policy JSON file (overrides .kdeploy.yml)
 
         #{@pastel.bright_yellow('🆕')} #{@pastel.bright_white('init [DIR]')}                  Initialize new deployment project
         #{@pastel.bright_yellow('ℹ️')} #{@pastel.bright_white('version')}                    Show version information

data/lib/kdeploy/{configuration.rb → config/configuration.rb}

@@ -12,6 +12,10 @@ module Kdeploy
     DEFAULT_RETRY_DELAY = 1
     DEFAULT_HOST_TIMEOUT = nil
     DEFAULT_RETRY_ON_NONZERO = false
+    DEFAULT_SYNC_FAST = false
+    DEFAULT_STEP_TIMEOUT = nil
+    DEFAULT_RETRY_POLICY = nil
+    DEFAULT_SYNC_PARALLEL = 1
     CONFIG_FILE_NAME = '.kdeploy.yml'
 
     class << self
@@ -21,7 +25,11 @@ module Kdeploy
                     :default_retries,
                     :default_retry_delay,
                     :default_host_timeout,
-                    :default_retry_on_nonzero
+                    :default_retry_on_nonzero,
+                    :default_sync_fast,
+                    :default_step_timeout,
+                    :default_retry_policy,
+                    :default_sync_parallel
 
       def reset
         @default_parallel = DEFAULT_PARALLEL
@@ -31,6 +39,10 @@ module Kdeploy
         @default_retry_delay = DEFAULT_RETRY_DELAY
         @default_host_timeout = DEFAULT_HOST_TIMEOUT
         @default_retry_on_nonzero = DEFAULT_RETRY_ON_NONZERO
+        @default_sync_fast = DEFAULT_SYNC_FAST
+        @default_step_timeout = DEFAULT_STEP_TIMEOUT
+        @default_retry_policy = DEFAULT_RETRY_POLICY
+        @default_sync_parallel = DEFAULT_SYNC_PARALLEL
       end
 
       def load_from_file(config_path = nil)
@@ -44,6 +56,22 @@ module Kdeploy
         nil
       end
 
+      # Load config for execute: CWD walk-up, then task file dir (overrides), then env vars.
+      def load_for_execute(task_dir: nil, cwd: Dir.pwd)
+        reset
+        load_from_file(find_config_file(cwd))
+        load_from_file(find_config_file(task_dir)) if task_dir
+        apply_env_overrides
+      end
+
+      def apply_env_overrides
+        parallel = positive_int_env('KDEPLOY_PARALLEL')
+        @default_parallel = parallel if parallel
+
+        ssh_timeout = positive_int_env('KDEPLOY_SSH_TIMEOUT')
+        @default_ssh_timeout = ssh_timeout if ssh_timeout
+      end
+
       def find_config_file(start_dir = Dir.pwd)
         current_dir = File.expand_path(start_dir)
 
@@ -72,6 +100,18 @@ module Kdeploy
         @default_retry_delay = config['retry_delay'] if config.key?('retry_delay')
         @default_host_timeout = config['host_timeout'] if config.key?('host_timeout')
         @default_retry_on_nonzero = config['retry_on_nonzero'] if config.key?('retry_on_nonzero')
+        @default_sync_fast = config['sync_fast'] if config.key?('sync_fast')
+        @default_step_timeout = config['step_timeout'] if config.key?('step_timeout')
+        @default_retry_policy = config['retry_policy'] if config.key?('retry_policy')
+        @default_sync_parallel = config['sync_parallel'] if config.key?('sync_parallel')
+      end
+
+      def positive_int_env(key)
+        raw = ENV.fetch(key, nil)
+        return nil if raw.nil? || raw.to_s.strip.empty?
+
+        value = raw.to_i
+        value.positive? ? value : nil
       end
 
       def parse_verify_host_key(value)

data/lib/kdeploy/{dsl.rb → dsl/dsl.rb}

@@ -161,7 +161,7 @@ module Kdeploy
       }
     end
 
-    def sync(source, destination, ignore: [], delete: false, exclude: [])
+    def sync(source, destination, ignore: [], delete: false, exclude: [], fast: nil, parallel: nil)
       @kdeploy_commands ||= []
       @kdeploy_commands << {
         type: :sync,
@@ -169,7 +169,9 @@ module Kdeploy
         destination: destination,
         ignore: Array(ignore),
         exclude: Array(exclude),
-        delete: delete
+        delete: delete,
+        fast: fast,
+        parallel: parallel
       }
     end
 
@@ -177,14 +179,14 @@ module Kdeploy
     # Chef-style resource DSL (compiles to run/upload/upload_template)
     # -------------------------------------------------------------------------
 
-    # 安装系统包。默认 apt 平台；支持 platform: :yum。
+    # Install a system package. Defaults to apt; supports platform: :yum.
     def package(name, version: nil, platform: :apt)
       @kdeploy_commands ||= []
       cmd = build_package_command(name, version, platform)
       @kdeploy_commands << { type: :run, command: cmd, sudo: true }
     end
 
-    # 管理系统服务（systemd）。action 支持 :start, :stop, :restart, :reload, :enable, :disable。
+    # Manage a systemd service. action supports :start, :stop, :restart, :reload, :enable, :disable.
     def service(name, action: :start)
       @kdeploy_commands ||= []
       actions = Array(action)
@@ -194,7 +196,7 @@ module Kdeploy
       end
     end
 
-    # 部署 ERB 模板到远程路径。支持 block 或关键字参数。
+    # Deploy an ERB template to a remote path. Supports block and keyword args.
     def template(destination, source: nil, variables: nil, &block)
       @kdeploy_commands ||= []
       if block
@@ -211,13 +213,13 @@ module Kdeploy
       upload_template(src, destination, vars)
     end
 
-    # 上传本地文件到远程路径。
+    # Upload a local file to a remote path.
     def file(destination, source:)
       @kdeploy_commands ||= []
       upload(source, destination)
     end
 
-    # 确保远程目录存在。支持 mode 参数。
+    # Ensure a remote directory exists. Supports mode option.
     def directory(path, mode: nil)
       @kdeploy_commands ||= []
       cmd = "mkdir -p #{Shellwords.escape(path.to_s)}"

data/lib/kdeploy/{initializer.rb → dsl/initializer.rb}

@@ -96,11 +96,11 @@ module Kdeploy
     end
 
     def create_config_files
-      # 创建配置目录
+      # Create config directory
       config_dir = File.join(@target_dir, 'config')
       FileUtils.mkdir_p(config_dir)
 
-      # 创建 Nginx ERB 模板
+      # Create Nginx ERB template
       File.write(File.join(config_dir, 'nginx.conf.erb'), <<~CONF)
         user nginx;
         worker_processes <%= worker_processes %>;
@@ -152,7 +152,7 @@ module Kdeploy
         }
       CONF
 
-      # 创建静态配置文件示例
+      # Create static config file example
       File.write(File.join(config_dir, 'app.conf'), <<~CONF)
         location /api {
             proxy_pass http://localhost:3000;

data/lib/kdeploy/errors.rb

@@ -52,6 +52,13 @@ module Kdeploy
     attr_reader :original_error
   end
 
+  # Raised when a step exceeds configured timeout
+  class StepTimeoutError < Error
+    def initialize(message)
+      super("Step timeout: #{message}")
+    end
+  end
+
   # Raised when configuration is invalid
   class ConfigurationError < Error
     def initialize(message)

data/lib/kdeploy/executor/command_executor.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Kdeploy
+  # Executes a single command and records execution time
+  class CommandExecutor
+    def initialize(executor, output, debug: false, retries: 0, retry_delay: 1, retry_on_nonzero: false,
+                   step_timeout: nil, retry_policy: nil)
+      @executor = executor
+      @output = output
+      @debug = debug
+      @retries = retries.to_i
+      @retry_delay = retry_delay.to_f
+      @retry_on_nonzero = retry_on_nonzero
+      @step_timeout = step_timeout&.to_f
+      @retry_policy = retry_policy
+    end
+
+    def execute_run(command, _host_name)
+      cmd = command[:command]
+      use_sudo = command[:sudo]
+
+      result, duration = measure_time do
+        with_retries(step_type: :run) do
+          with_timeout { @executor.execute(cmd, use_sudo: use_sudo) }
+        end
+      end
+
+      { command: cmd, output: result, duration: duration, type: :run }
+    end
+
+    def execute_upload(command, _host_name)
+      _result, duration = measure_time do
+        with_retries(step_type: :upload) do
+          with_timeout { @executor.upload(command[:source], command[:destination]) }
+        end
+      end
+      {
+        command: "upload: #{command[:source]} -> #{command[:destination]}",
+        duration: duration,
+        type: :upload
+      }
+    end
+
+    def execute_upload_template(command, _host_name)
+      _result, duration = measure_time do
+        with_retries(step_type: :upload_template) do
+          with_timeout do
+            @executor.upload_template(command[:source], command[:destination], command[:variables])
+          end
+        end
+      end
+      {
+        command: "upload_template: #{command[:source]} -> #{command[:destination]}",
+        duration: duration,
+        type: :upload_template
+      }
+    end
+
+    def execute_sync(command, _host_name)
+      source = command[:source]
+      destination = command[:destination]
+      fast = command.key?(:fast) ? command[:fast] : Configuration.default_sync_fast
+      parallel = command.key?(:parallel) ? command[:parallel] : Configuration.default_sync_parallel
+
+      result, duration = measure_time do
+        with_retries(step_type: :sync) do
+          with_timeout do
+            @executor.sync_directory(
+              source,
+              destination,
+              ignore: command[:ignore] || [],
+              exclude: command[:exclude] || [],
+              delete: command[:delete] || false,
+              fast: fast,
+              parallel: parallel
+            )
+          end
+        end
+      end
+
+      build_sync_result(source, destination, result, duration)
+    end
+
+    private
+
+    def build_sync_result(source, destination, result, duration)
+      {
+        command: "sync: #{source} -> #{destination}",
+        duration: duration,
+        type: :sync,
+        result: result,
+        uploaded: result[:uploaded],
+        deleted: result[:deleted],
+        total: result[:total]
+      }
+    end
+
+    def measure_time
+      start_time = Time.now
+      result = yield
+      duration = Time.now - start_time
+      [result, duration]
+    end
+
+    def with_retries(step_type: nil)
+      attempts = 0
+      max_retries = retries_for(step_type)
+      exit_codes = retry_exit_codes_for(step_type)
+      begin
+        attempts += 1
+        yield
+      rescue SSHError, SCPError, TemplateError => e
+        raise if e.is_a?(SSHError) && e.exit_status && !retry_on_exit_status?(e.exit_status, exit_codes)
+        raise if attempts > (max_retries + 1)
+
+        sleep(@retry_delay) if @retry_delay.positive?
+        retry
+      end
+    end
+
+    def with_timeout(&block)
+      return yield unless @step_timeout&.positive?
+
+      Timeout.timeout(@step_timeout, &block)
+    rescue Timeout::Error
+      raise StepTimeoutError, "exceeded #{@step_timeout}s"
+    end
+
+    def retries_for(step_type)
+      return @retries unless @retry_policy.is_a?(Hash) && step_type
+
+      policy = @retry_policy[step_type.to_s] || @retry_policy[step_type.to_sym]
+      return @retries unless policy.is_a?(Hash)
+
+      policy.fetch('retries', policy.fetch(:retries, @retries)).to_i
+    end
+
+    def retry_exit_codes_for(step_type)
+      return nil unless @retry_policy.is_a?(Hash) && step_type
+
+      policy = @retry_policy[step_type.to_s] || @retry_policy[step_type.to_sym]
+      return nil unless policy.is_a?(Hash)
+
+      policy['retry_on_exit_codes'] || policy[:retry_on_exit_codes]
+    end
+
+    def retry_on_exit_status?(exit_status, exit_codes)
+      return @retry_on_nonzero if exit_codes.nil?
+
+      Array(exit_codes).map(&:to_i).include?(exit_status.to_i)
+    end
+  end
+end