kdeploy 1.2.41 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9bab827b041d7b33e3486ddcddc0956fa7b00fddbd20275709c8e23f5201f7a
-  data.tar.gz: c7eee9c23f27b9541a4ef09c253ae5bffa9e9ae5715a941eb36f363afb5a6122
+  metadata.gz: 782163100dc54c6588d66c1655434a9ab4f6a0cd3aa5d97583e4b9e5fb757bbd
+  data.tar.gz: 38c8a9e92920dcdbfdca974a9ed4a51579cb618cc2a80fedcdaf19f0fe73fd80
 SHA512:
-  metadata.gz: 9fb85d1b6243a36259f67a6d9c96e1028190a7d650a5b625d4b31f76f5bd2eb12adcce06e07c7c12177ffaa128fa32a561e8b8092674ca51df2d4c6e6d5d2790
-  data.tar.gz: 6dd1ad95b47ecf2b0d8d09ee3f2994c4caccfb248894f9ca0c374a66fe9121a427726421ad9ceb0ce30512adb34080a7c39bb7c7789022dcff5531ec8131e003
+  metadata.gz: bcf659df1c65bfc50c0ebdb57a7b9f689a74c9db7107f7d3c48beb869b37633b2b887f02ca27f8f0b1707c5a593b8727e0416754221654c31faeaa1c1ddc2a3c
+  data.tar.gz: 2fa594ddb0cf3196dc1abcfd9ae9fb54729b91907445912a0e10cd4aa5d7da83c42ac9dbab02ee33e8d824b38ef25408f35e7791108e9b26728a1b96507bd816

data/README.md

@@ -207,6 +207,8 @@ kdeploy execute deploy.rb deploy_web
 - `--format FORMAT`: 输出格式（`text`|`json`，默认 `text`）
 - `--retries N`: 网络相关操作重试次数（默认 `0`）
 - `--retry-delay SECONDS`: 每次重试间隔秒数（默认 `1`）
+- `--retry-on-nonzero`: 非零退出码重试开关（默认 `false`）
+- `--timeout SECONDS`: 单 host 执行超时（秒，默认不启用）
 
 **示例:**
 ```bash
@@ -228,6 +230,12 @@ kdeploy execute deploy.rb deploy_web --format json --no-banner
 # 重试网络抖动导致的失败
 kdeploy execute deploy.rb deploy_web --retries 3 --retry-delay 1
 
+# 对非零退出码进行重试
+kdeploy execute deploy.rb deploy_web --retries 2 --retry-on-nonzero
+
+# 设置单 host 超时（秒）
+kdeploy execute deploy.rb deploy_web --timeout 120
+
 # 组合选项
 kdeploy execute deploy.rb deploy_web --limit web01 --parallel 3 --dry-run
 ```
@@ -1141,4 +1149,3 @@ end
 ---
 
 **为 DevOps 社区用 ❤️ 制作**
-

data/README_EN.md

@@ -206,6 +206,8 @@ kdeploy execute deploy.rb deploy_web
 - `--format FORMAT`: Output format (`text`|`json`, default `text`)
 - `--retries N`: Retry count for network operations (default `0`)
 - `--retry-delay SECONDS`: Delay between retries in seconds (default `1`)
+- `--retry-on-nonzero`: Retry commands on nonzero exit status (default `false`)
+- `--timeout SECONDS`: Per-host execution timeout in seconds (default: none)
 
 **Examples:**
 ```bash
@@ -227,6 +229,12 @@ kdeploy execute deploy.rb deploy_web --format json --no-banner
 # Retry transient network failures
 kdeploy execute deploy.rb deploy_web --retries 3 --retry-delay 1
 
+# Retry on nonzero exit status
+kdeploy execute deploy.rb deploy_web --retries 2 --retry-on-nonzero
+
+# Set per-host timeout (seconds)
+kdeploy execute deploy.rb deploy_web --timeout 120
+
 # Combine options
 kdeploy execute deploy.rb deploy_web --limit web01 --parallel 3 --dry-run
 ```

data/lib/kdeploy/cli.rb

@@ -51,6 +51,8 @@ module Kdeploy
     method_option :format, type: :string, default: 'text', desc: 'Output format (text|json)'
     method_option :retries, type: :numeric, desc: 'Retry count for network operations (default: 0)'
     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)'
     def execute(task_file, task_name = nil)
       load_config_file
       show_banner_once
@@ -267,6 +269,9 @@ module Kdeploy
       debug_mode = options[:debug] || false
       retries = options[:retries].nil? ? Configuration.default_retries : options[:retries]
       retry_delay = options[:retry_delay].nil? ? Configuration.default_retry_delay : options[:retry_delay]
+      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]
       base_dir = @task_file_dir
       runner = Runner.new(
         hosts, self.class.kdeploy_tasks,
@@ -275,7 +280,9 @@ module Kdeploy
         debug: debug_mode,
         base_dir: base_dir,
         retries: retries,
-        retry_delay: retry_delay
+        retry_delay: retry_delay,
+        retry_on_nonzero: retry_on_nonzero,
+        host_timeout: host_timeout
       )
       results = runner.run(task)
       if options[:format] == 'json'
@@ -363,6 +370,8 @@ 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)

data/lib/kdeploy/command_executor.rb

@@ -3,12 +3,13 @@
 module Kdeploy
   # Executes a single command and records execution time
   class CommandExecutor
-    def initialize(executor, output, debug: false, retries: 0, retry_delay: 1)
+    def initialize(executor, output, debug: false, retries: 0, retry_delay: 1, retry_on_nonzero: false)
       @executor = executor
       @output = output
       @debug = debug
       @retries = retries.to_i
       @retry_delay = retry_delay.to_f
+      @retry_on_nonzero = retry_on_nonzero
     end
 
     def execute_run(command, _host_name)
@@ -91,7 +92,8 @@ module Kdeploy
       begin
         attempts += 1
         yield
-      rescue SSHError, SCPError, TemplateError
+      rescue SSHError, SCPError, TemplateError => e
+        raise if e.is_a?(SSHError) && e.exit_status && !@retry_on_nonzero
         raise if attempts > (@retries + 1)
 
         sleep(@retry_delay) if @retry_delay.positive?

data/lib/kdeploy/configuration.rb

@@ -10,6 +10,8 @@ module Kdeploy
     DEFAULT_VERIFY_HOST_KEY = :never
     DEFAULT_RETRIES = 0
     DEFAULT_RETRY_DELAY = 1
+    DEFAULT_HOST_TIMEOUT = nil
+    DEFAULT_RETRY_ON_NONZERO = false
     CONFIG_FILE_NAME = '.kdeploy.yml'
 
     class << self
@@ -17,7 +19,9 @@ module Kdeploy
                     :default_ssh_timeout,
                     :default_verify_host_key,
                     :default_retries,
-                    :default_retry_delay
+                    :default_retry_delay,
+                    :default_host_timeout,
+                    :default_retry_on_nonzero
 
       def reset
         @default_parallel = DEFAULT_PARALLEL
@@ -25,6 +29,8 @@ module Kdeploy
         @default_verify_host_key = DEFAULT_VERIFY_HOST_KEY
         @default_retries = DEFAULT_RETRIES
         @default_retry_delay = DEFAULT_RETRY_DELAY
+        @default_host_timeout = DEFAULT_HOST_TIMEOUT
+        @default_retry_on_nonzero = DEFAULT_RETRY_ON_NONZERO
       end
 
       def load_from_file(config_path = nil)
@@ -64,6 +70,8 @@ module Kdeploy
         @default_verify_host_key = parse_verify_host_key(config['verify_host_key']) if config.key?('verify_host_key')
         @default_retries = config['retries'] if config.key?('retries')
         @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')
       end
 
       def parse_verify_host_key(value)

data/lib/kdeploy/help_formatter.rb

@@ -34,6 +34,8 @@ module Kdeploy
         #{@pastel.dim('    --format FORMAT')}            Output format (text|json)
         #{@pastel.dim('    --retries N')}                Retry count for network operations (default: 0; overridden by .kdeploy.yml)
         #{@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.bright_yellow('🆕')} #{@pastel.bright_white('init [DIR]')}                  Initialize new deployment project
         #{@pastel.bright_yellow('ℹ️')} #{@pastel.bright_white('version')}                    Show version information

data/lib/kdeploy/runner.rb

@@ -7,7 +7,9 @@ module Kdeploy
   class Runner
     def initialize(hosts, tasks, parallel: Configuration.default_parallel, output: ConsoleOutput.new,
                    debug: false, base_dir: nil, retries: Configuration.default_retries,
-                   retry_delay: Configuration.default_retry_delay)
+                   retry_delay: Configuration.default_retry_delay,
+                   retry_on_nonzero: Configuration.default_retry_on_nonzero,
+                   host_timeout: Configuration.default_host_timeout)
       @hosts = hosts
       @tasks = tasks
       @parallel = parallel
@@ -16,6 +18,8 @@ module Kdeploy
       @base_dir = base_dir
       @retries = retries
       @retry_delay = retry_delay
+      @retry_on_nonzero = retry_on_nonzero
+      @host_timeout = normalize_timeout(host_timeout)
       @pool = Concurrent::FixedThreadPool.new(@parallel)
       @results = Concurrent::Hash.new
     end
@@ -41,59 +45,48 @@ module Kdeploy
       # If no hosts, return empty results immediately
       return @results if futures.empty?
 
-      # Collect results from futures
-      futures.each_with_index do |future, index|
-        host_name = @host_names[index] # Get host name from the stored list
-        begin
-          # Wait for future to complete and get its value
-          # This ensures the future has finished executing
-          future_result = future.value
-
-          # Handle the result
-          if future_result.nil?
-            # Future returned nil - create a default result
-            @results[host_name] = { status: :unknown, error: 'Future returned nil', output: [] }
-          elsif future_result.is_a?(Array) && future_result.length == 2
-            name, result = future_result
-            # Store the result using the name from the future
-            @results[name] = result
-          else
-            # Handle unexpected result format - create a default result
-            @results[host_name] = {
-              status: :unknown,
-              error: "Unexpected result format: #{future_result.class}",
+      pending = futures.dup
+
+      until pending.empty?
+        progressed = false
+        now = Time.now
+
+        pending.dup.each do |future|
+          meta = @future_meta[future]
+          host_name = meta[:host_name]
+          started_at = meta[:started_at].get
+
+          if future.fulfilled? || future.rejected?
+            collect_future_result(future, host_name)
+            pending.delete(future)
+            progressed = true
+          elsif timeout_exceeded?(started_at, now)
+            @results[host_name] ||= {
+              status: :failed,
+              error: "execution timeout after #{@host_timeout}s",
               output: []
             }
+            pending.delete(future)
+            progressed = true
           end
-
-          # Check if future raised an exception
-          if future.rejected?
-            error = begin
-              future.reason
-            rescue StandardError
-              'Unknown error'
-            end
-            @results[host_name] = { status: :failed, error: error, output: [] } unless @results.key?(host_name)
-          end
-        rescue StandardError => e
-          # If future.value raises an exception, create an error result
-          @results[host_name] = { status: :failed, error: "#{e.class}: #{e.message}", output: [] }
-        ensure
-          # Ensure we always have a result for this host
-          @results[host_name] ||= { status: :unknown, error: 'No result collected', output: [] }
         end
+
+        sleep(0.05) unless progressed
       end
 
       @results
     end
 
     def create_task_futures(task, task_name)
-      # Store host names in order to match with futures
-      @host_names = @hosts.keys
+      @future_meta = {}
       @hosts.map do |name, config|
-        Concurrent::Future.execute(executor: @pool) do
+        started_at = Concurrent::AtomicReference.new(nil)
+        future = Concurrent::Future.execute(executor: @pool) do
+          started_at.set(Time.now)
           execute_task_for_host(name, config, task, task_name)
         end
+        @future_meta[future] = { host_name: name, started_at: started_at }
+        future
       end
     end
 
@@ -108,7 +101,8 @@ module Kdeploy
         @output,
         debug: @debug,
         retries: @retries,
-        retry_delay: @retry_delay
+        retry_delay: @retry_delay,
+        retry_on_nonzero: @retry_on_nonzero
       )
       result = { status: :success, output: [] }
 
@@ -133,7 +127,7 @@ module Kdeploy
       rescue StandardError => e
         step = step_description(command)
         result[:status] = :failed
-        result[:error] = "task=#{task_name} host=#{name} step=#{step} error=#{e.class}: #{e.message}"
+        result[:error] = build_step_error(task_name, name, step, e)
         result[:output] << {
           type: command[:type],
           command: step_command_string(command),
@@ -145,6 +139,53 @@ module Kdeploy
       end
     end
 
+    def collect_future_result(future, host_name)
+      return if @results.key?(host_name)
+
+      begin
+        future_result = future.value
+        if future_result.nil?
+          @results[host_name] = { status: :unknown, error: 'Future returned nil', output: [] }
+        elsif future_result.is_a?(Array) && future_result.length == 2
+          name, result = future_result
+          @results[name] = result
+        else
+          @results[host_name] = {
+            status: :unknown,
+            error: "Unexpected result format: #{future_result.class}",
+            output: []
+          }
+        end
+
+        if future.rejected?
+          error = begin
+            future.reason
+          rescue StandardError
+            'Unknown error'
+          end
+          @results[host_name] ||= { status: :failed, error: error, output: [] }
+        end
+      rescue StandardError => e
+        @results[host_name] = { status: :failed, error: "#{e.class}: #{e.message}", output: [] }
+      ensure
+        @results[host_name] ||= { status: :unknown, error: 'No result collected', output: [] }
+      end
+    end
+
+    def timeout_exceeded?(started_at, now)
+      return false unless @host_timeout
+      return false if started_at.nil?
+
+      (now - started_at) > @host_timeout
+    end
+
+    def normalize_timeout(timeout)
+      return nil if timeout.nil?
+
+      timeout = timeout.to_f
+      timeout.positive? ? timeout : nil
+    end
+
     def error_output_for_step(error)
       return nil unless error.is_a?(Kdeploy::SSHError)
 
@@ -156,6 +197,17 @@ module Kdeploy
       }
     end
 
+    def build_step_error(task_name, host_name, step, error)
+      base = "task=#{task_name} host=#{host_name} step=#{step} error=#{error.class}: #{error.message}"
+      return base unless error.is_a?(Kdeploy::SSHError)
+
+      if error.exit_status
+        "#{base} exit_status=#{error.exit_status} command=#{error.command}"
+      else
+        base
+      end
+    end
+
     def execute_command(command_executor, command, host_name)
       case command[:type]
       when :run

data/lib/kdeploy/version.rb

@@ -2,5 +2,5 @@
 
 # Kdeploy module for version management
 module Kdeploy
-  VERSION = '1.2.41' unless const_defined?(:VERSION)
+  VERSION = '1.3.1' unless const_defined?(:VERSION)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.2.41
+  version: 1.3.1
 platform: ruby
 authors:
 - Kk
@@ -184,7 +184,6 @@ files:
 - lib/kdeploy/runner.rb
 - lib/kdeploy/template.rb
 - lib/kdeploy/version.rb
-- r.md
 homepage: https://github.com/kevin197011/kdeploy
 licenses:
 - MIT

data/r.md

@@ -1 +0,0 @@
-# Your product documentation