kdeploy 1.2.30 → 1.2.38

data/lib/kdeploy/command_executor.rb

@@ -3,36 +3,28 @@
 module Kdeploy
   # Executes a single command and records execution time
   class CommandExecutor
-    def initialize(executor, output, debug: false)
+    def initialize(executor, output, debug: false, retries: 0, retry_delay: 1)
       @executor = executor
       @output = output
       @debug = debug
+      @retries = retries.to_i
+      @retry_delay = retry_delay.to_f
     end
 
-    def execute_run(command, host_name)
+    def execute_run(command, _host_name)
       cmd = command[:command]
       use_sudo = command[:sudo]
-      show_command_header(host_name, :run, cmd)
-
-      # Show progress indicator for long-running commands
-      pastel = @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
 
       result, duration = measure_time do
-        @executor.execute(cmd, use_sudo: use_sudo)
+        with_retries { @executor.execute(cmd, use_sudo: use_sudo) }
       end
 
-      # Show execution time if command took more than 1 second
-      @output.write_line(pastel.dim("    [completed in #{format('%.2f', duration)}s]")) if duration > 1.0
-
-      # Show command output only in debug mode
-      show_command_output(result) if @debug
       { command: cmd, output: result, duration: duration, type: :run }
     end
 
-    def execute_upload(command, host_name)
-      show_command_header(host_name, :upload, "#{command[:source]} -> #{command[:destination]}")
+    def execute_upload(command, _host_name)
       _result, duration = measure_time do
-        @executor.upload(command[:source], command[:destination])
+        with_retries { @executor.upload(command[:source], command[:destination]) }
       end
       {
         command: "upload: #{command[:source]} -> #{command[:destination]}",
@@ -41,10 +33,11 @@ module Kdeploy
       }
     end
 
-    def execute_upload_template(command, host_name)
-      show_command_header(host_name, :upload_template, "#{command[:source]} -> #{command[:destination]}")
+    def execute_upload_template(command, _host_name)
       _result, duration = measure_time do
-        @executor.upload_template(command[:source], command[:destination], command[:variables])
+        with_retries do
+          @executor.upload_template(command[:source], command[:destination], command[:variables])
+        end
       end
       {
         command: "upload_template: #{command[:source]} -> #{command[:destination]}",
@@ -53,20 +46,20 @@ module Kdeploy
       }
     end
 
-    def execute_sync(command, host_name)
+    def execute_sync(command, _host_name)
       source = command[:source]
       destination = command[:destination]
-      description = build_sync_description(source, destination, command[:delete])
-      show_command_header(host_name, :sync, description)
 
       result, duration = measure_time do
-        @executor.sync_directory(
-          source,
-          destination,
-          ignore: command[:ignore] || [],
-          exclude: command[:exclude] || [],
-          delete: command[:delete] || false
-        )
+        with_retries do
+          @executor.sync_directory(
+            source,
+            destination,
+            ignore: command[:ignore] || [],
+            exclude: command[:exclude] || [],
+            delete: command[:delete] || false
+          )
+        end
       end
 
       build_sync_result(source, destination, result, duration)
@@ -74,12 +67,6 @@ module Kdeploy
 
     private
 
-    def build_sync_description(source, destination, delete)
-      desc = "sync: #{source} -> #{destination}"
-      desc += " (delete: #{delete})" if delete
-      desc
-    end
-
     def build_sync_result(source, destination, result, duration)
       {
         command: "sync: #{source} -> #{destination}",
@@ -99,54 +86,16 @@ module Kdeploy
       [result, duration]
     end
 
-    def show_command_output(output)
-      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?
-
-      stdout.each_line do |line|
-        @output.write_line("    #{line.rstrip}") unless line.strip.empty?
-      end
-    end
-
-    def show_stderr(stderr, pastel)
-      return unless stderr && !stderr.empty?
-
-      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)
-      # Don't show command header during execution - it will be shown in results
-      # This reduces noise during execution
-    end
-
-    def pastel_instance
-      @output.respond_to?(:pastel) ? @output.pastel : Pastel.new
-    end
-
-    def format_command_by_type(type, description, pastel)
-      case type
-      when :run
-        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 with_retries
+      attempts = 0
+      begin
+        attempts += 1
+        yield
+      rescue SSHError, SCPError, TemplateError
+        raise if attempts > (@retries + 1)
 
-    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?
+        sleep(@retry_delay) if @retry_delay.positive?
+        retry
       end
     end
   end

data/lib/kdeploy/configuration.rb

@@ -8,17 +8,23 @@ module Kdeploy
     DEFAULT_PARALLEL = 10
     DEFAULT_SSH_TIMEOUT = 30
     DEFAULT_VERIFY_HOST_KEY = :never
+    DEFAULT_RETRIES = 0
+    DEFAULT_RETRY_DELAY = 1
     CONFIG_FILE_NAME = '.kdeploy.yml'
 
     class << self
       attr_accessor :default_parallel,
                     :default_ssh_timeout,
-                    :default_verify_host_key
+                    :default_verify_host_key,
+                    :default_retries,
+                    :default_retry_delay
 
       def reset
         @default_parallel = DEFAULT_PARALLEL
         @default_ssh_timeout = DEFAULT_SSH_TIMEOUT
         @default_verify_host_key = DEFAULT_VERIFY_HOST_KEY
+        @default_retries = DEFAULT_RETRIES
+        @default_retry_delay = DEFAULT_RETRY_DELAY
       end
 
       def load_from_file(config_path = nil)
@@ -56,6 +62,8 @@ module Kdeploy
         @default_parallel = config['parallel'] if config.key?('parallel')
         @default_ssh_timeout = config['ssh_timeout'] if config.key?('ssh_timeout')
         @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')
       end
 
       def parse_verify_host_key(value)

data/lib/kdeploy/dsl.rb

@@ -1,16 +1,56 @@
 # frozen_string_literal: true
 
 require 'set'
+require 'shellwords'
 
 module Kdeploy
+  # Helper for template resource block: captures source and variables
+  class TemplateOptions
+    def initialize
+      @source = nil
+      @variables = {}
+    end
+
+    def variables(val = nil)
+      @variables = val if val
+      @variables
+    end
+
+    def source(val = nil)
+      @source = val if val
+      @source
+    end
+  end
+
   # Domain-specific language for defining hosts, roles, and tasks
   module DSL
+    def self.included(base)
+      # Support `include Kdeploy::DSL` by promoting the DSL methods to class methods.
+      # This keeps tests and external integrations simpler while preserving the
+      # primary usage pattern (CLI uses `extend DSL`).
+      base.extend(self)
+    end
+
     def self.extended(base)
       base.instance_variable_set(:@kdeploy_hosts, {})
       base.instance_variable_set(:@kdeploy_tasks, {})
       base.instance_variable_set(:@kdeploy_roles, {})
     end
 
+    # Stable read accessors for tests/integrations.
+    # Keep these as aliases so internal storage can evolve without breaking callers.
+    def hosts
+      kdeploy_hosts
+    end
+
+    def tasks
+      kdeploy_tasks
+    end
+
+    def roles
+      kdeploy_roles
+    end
+
     def kdeploy_hosts
       @kdeploy_hosts ||= {}
     end
@@ -133,6 +173,60 @@ module Kdeploy
       }
     end
 
+    # -------------------------------------------------------------------------
+    # Chef-style resource DSL (compiles to run/upload/upload_template)
+    # -------------------------------------------------------------------------
+
+    # 安装系统包。默认 apt 平台；支持 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。
+    def service(name, action: :start)
+      @kdeploy_commands ||= []
+      actions = Array(action)
+      actions.each do |a|
+        cmd = "systemctl #{a} #{Shellwords.escape(name.to_s)}"
+        @kdeploy_commands << { type: :run, command: cmd, sudo: true }
+      end
+    end
+
+    # 部署 ERB 模板到远程路径。支持 block 或关键字参数。
+    def template(destination, source: nil, variables: nil, &block)
+      @kdeploy_commands ||= []
+      if block
+        opts = TemplateOptions.new
+        opts.instance_eval(&block)
+        src = opts.source || raise(ArgumentError, 'template requires source')
+        vars = opts.variables || {}
+      else
+        raise ArgumentError, 'template requires source' unless source
+
+        src = source
+        vars = variables || {}
+      end
+      upload_template(src, destination, vars)
+    end
+
+    # 上传本地文件到远程路径。
+    def file(destination, source:)
+      @kdeploy_commands ||= []
+      upload(source, destination)
+    end
+
+    # 确保远程目录存在。支持 mode 参数。
+    def directory(path, mode: nil)
+      @kdeploy_commands ||= []
+      cmd = "mkdir -p #{Shellwords.escape(path.to_s)}"
+      @kdeploy_commands << { type: :run, command: cmd, sudo: true }
+      return unless mode
+
+      @kdeploy_commands << { type: :run, command: "chmod #{mode} #{Shellwords.escape(path.to_s)}", sudo: true }
+    end
+
     def inventory(&block)
       instance_eval(&block) if block_given?
     end
@@ -167,5 +261,20 @@ module Kdeploy
         end
       end
     end
+
+    def build_package_command(name, version, platform)
+      n = Shellwords.escape(name.to_s)
+      case platform.to_sym
+      when :yum, :rpm
+        if version
+          "yum install -y #{n}-#{Shellwords.escape(version.to_s)}"
+        else
+          "yum install -y #{n}"
+        end
+      else
+        base = "apt-get update && apt-get install -y #{n}"
+        version ? "#{base}=#{Shellwords.escape(version.to_s)}" : base
+      end
+    end
   end
 end

data/lib/kdeploy/errors.rb

@@ -20,12 +20,16 @@ module Kdeploy
 
   # Raised when SSH operation fails
   class SSHError < Error
-    def initialize(message, original_error = nil)
+    def initialize(message, original_error = nil, command: nil, exit_status: nil, stdout: nil, stderr: nil)
       super("SSH operation failed: #{message}")
       @original_error = original_error
+      @command = command
+      @exit_status = exit_status
+      @stdout = stdout
+      @stderr = stderr
     end
 
-    attr_reader :original_error
+    attr_reader :original_error, :command, :exit_status, :stdout, :stderr
   end
 
   # Raised when SCP operation fails

data/lib/kdeploy/executor.rb

@@ -38,16 +38,21 @@ module Kdeploy
     def execute_command_on_ssh(ssh, command)
       stdout = String.new
       stderr = String.new
+      exit_status = nil
 
       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)
+          channel.on_request('exit-status') do |_ch, data|
+            exit_status = data.read_long
+          end
         end
       end
       ssh.loop
-      build_command_result(stdout, stderr, command)
+      raise_nonzero_exit!(command, exit_status, stdout, stderr)
+      build_command_result(stdout, stderr, command, exit_status)
     end
 
     def setup_channel_handlers(channel, stdout, stderr)
@@ -60,14 +65,29 @@ module Kdeploy
       end
     end
 
-    def build_command_result(stdout, stderr, command)
+    def build_command_result(stdout, stderr, command, exit_status)
       {
         stdout: stdout.strip,
         stderr: stderr.strip,
-        command: command
+        command: command,
+        exit_status: exit_status
       }
     end
 
+    def raise_nonzero_exit!(command, exit_status, stdout, stderr)
+      return if exit_status.nil?
+      return if exit_status.zero?
+
+      raise SSHError.new(
+        "Command exited with status #{exit_status}",
+        nil,
+        command: command,
+        exit_status: exit_status,
+        stdout: stdout.strip,
+        stderr: stderr.strip
+      )
+    end
+
     def upload(source, destination, use_sudo: nil)
       use_sudo = @use_sudo if use_sudo.nil?
 

data/lib/kdeploy/file_filter.rb

@@ -47,8 +47,14 @@ module Kdeploy
                   .gsub('[!', '[^')          # [^...] negation
                   .gsub('[', '[')            # Character class
 
-      # Anchor to start if pattern doesn't start with **
-      regex_str = "^#{regex_str}" unless pattern.start_with?('**')
+      # gitignore semantics: patterns without a slash match in any directory.
+      # e.g. "*.log" should match "a.log" and "logs/a.log".
+      if !pattern.include?('/') && !pattern.start_with?('**')
+        regex_str = "(?:^|.*/)#{regex_str}"
+      elsif !pattern.start_with?('**')
+        regex_str = "^#{regex_str}"
+      end
+
       # Match end of string or directory separator
       regex_str = "#{regex_str}(/|$)" unless pattern.end_with?('*') || pattern.end_with?('**')
 
@@ -64,8 +70,13 @@ module Kdeploy
     def relative_path_for(file_path, base_path)
       return file_path.to_s unless base_path
 
+      file = Pathname.new(file_path.to_s)
+
+      # If caller already passed a relative path (common in sync traversal),
+      # keep it as-is to avoid Pathname#relative_path_from prefix errors.
+      return file_path.to_s unless file.absolute?
+
       base = Pathname.new(base_path)
-      file = Pathname.new(file_path)
       file.relative_path_from(base).to_s
     end
   end

data/lib/kdeploy/help_formatter.rb

@@ -27,8 +27,13 @@ module Kdeploy
       <<~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('    --parallel NUM')}             Number of parallel executions (default: 10; overridden by .kdeploy.yml)
         #{@pastel.dim('    --dry-run')}                  Show what would be done without executing
+        #{@pastel.dim('    --debug')}                    Show detailed command output (stdout/stderr)
+        #{@pastel.dim('    --no-banner')}                Do not print banner (automation-friendly)
+        #{@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.bright_yellow('🆕')} #{@pastel.bright_white('init [DIR]')}                  Initialize new deployment project
         #{@pastel.bright_yellow('ℹ️')} #{@pastel.bright_white('version')}                    Show version information
@@ -54,6 +59,12 @@ module Kdeploy
 
         #{@pastel.dim('# Preview deployment')}
         #{@pastel.bright_cyan('kdeploy execute deploy.rb deploy_web --dry-run')}
+
+        #{@pastel.dim('# Machine-readable output')}
+        #{@pastel.bright_cyan('kdeploy execute deploy.rb deploy_web --format json --no-banner')}
+
+        #{@pastel.dim('# Retry transient network failures')}
+        #{@pastel.bright_cyan('kdeploy execute deploy.rb deploy_web --retries 3 --retry-delay 1')}
       EXAMPLES
     end
 

data/lib/kdeploy/initializer.rb

@@ -39,27 +39,21 @@ module Kdeploy
         role :web, %w[web01 web02]
         role :db, %w[db01]
 
-        # Define deployment task for web servers
+        # Define deployment task for web servers (Chef-style resource DSL)
         task :deploy_web, roles: :web do
-          # Example: Using sudo option for specific command
-          # run "systemctl stop nginx", sudo: true
-          run <<~SHELL
-            sudo systemctl stop nginx
-            echo "Deploying..."
-          SHELL
-
-          upload_template './config/nginx.conf.erb', '/etc/nginx/nginx.conf',
-            domain_name: 'example.com',
-            port: 3000,
-            worker_processes: 4,
-            worker_connections: 2048
-
-          upload './config/app.conf', '/etc/nginx/conf.d/app.conf'
-
-          run <<~SHELL
-            sudo systemctl start nginx
-            sudo systemctl status nginx
-          SHELL
+          package 'nginx'
+          directory '/etc/nginx/conf.d'
+          template '/etc/nginx/nginx.conf',
+            source: './config/nginx.conf.erb',
+            variables: {
+              domain_name: 'example.com',
+              port: 3000,
+              worker_processes: 4,
+              worker_connections: 2048
+            }
+          file '/etc/nginx/conf.d/app.conf', source: './config/app.conf'
+          run 'nginx -t', sudo: true
+          service 'nginx', action: %i[enable restart]
         end
 
         # Define backup task for database servers
@@ -71,13 +65,11 @@ module Kdeploy
           SHELL
         end
 
-        # Define task for specific hosts
+        # Define task for specific hosts (resource DSL example)
         task :maintenance, on: %w[web01] do
-          run <<~SHELL
-            sudo systemctl stop nginx
-            sudo apt-get update && sudo apt-get upgrade -y
-            sudo systemctl start nginx
-          SHELL
+          service 'nginx', action: :stop
+          run 'apt-get update && apt-get upgrade -y', sudo: true
+          service 'nginx', action: %i[start enable]
         end
 
         # Define task for all hosts
@@ -199,12 +191,12 @@ module Kdeploy
         server_name <%= domain_name %>;
         ```
 
-        Variables are passed when uploading the template:
+        Variables are passed when uploading the template (Chef-style resource DSL):
 
         ```ruby
-        upload_template "./config/nginx.conf.erb", "/etc/nginx/nginx.conf",
-          domain_name: "example.com",
-          worker_processes: 4
+        template "/etc/nginx/nginx.conf",
+          source: "./config/nginx.conf.erb",
+          variables: { domain_name: "example.com", worker_processes: 4 }
         ```
 
         ## 🔐 Using Sudo