kdeploy 1.3.1 → 1.3.4

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

@@ -5,6 +5,8 @@ require 'net/scp'
 require 'pathname'
 require 'find'
 require 'shellwords'
+require 'tempfile'
+require 'concurrent'
 require_relative 'file_filter'
 
 module Kdeploy
@@ -16,7 +18,7 @@ module Kdeploy
       @ip = host_config[:ip]
       @password = host_config[:password]
       @key = host_config[:key]
-      @port = host_config[:port] # 新增端口支持
+      @port = host_config[:port] # Added custom port support
       @use_sudo = host_config[:use_sudo] || false
       @sudo_password = host_config[:sudo_password]
       @base_dir = host_config[:base_dir] # Base directory for resolving relative paths
@@ -114,7 +116,8 @@ module Kdeploy
       raise TemplateError.new("Template upload failed: #{e.message}", e)
     end
 
-    def sync_directory(source, destination, ignore: [], exclude: [], delete: false, use_sudo: nil)
+    def sync_directory(source, destination, ignore: [], exclude: [], delete: false, fast: nil, parallel: nil,
+                       use_sudo: nil)
       use_sudo = @use_sudo if use_sudo.nil?
 
       # Resolve relative paths relative to base_dir
@@ -127,24 +130,29 @@ module Kdeploy
       all_patterns = ignore + exclude
       filter = FileFilter.new(ignore_patterns: all_patterns)
 
+      if fast
+        rsync_result = sync_with_rsync(
+          resolved_source,
+          destination,
+          ignore: ignore,
+          exclude: exclude,
+          delete: delete,
+          use_sudo: use_sudo
+        )
+        return rsync_result if rsync_result
+      end
+
       # Collect files to sync
       files_to_sync = collect_files_to_sync(resolved_source, filter)
 
       # Upload files
-      uploaded_count = 0
-      source_path = Pathname.new(resolved_source)
-      files_to_sync.each do |file_path|
-        relative_path = Pathname.new(file_path).relative_path_from(source_path).to_s
-        remote_path = File.join(destination, relative_path).gsub(%r{/+}, '/')
-
-        # Ensure remote directory exists
-        remote_dir = File.dirname(remote_path)
-        ensure_remote_directory(remote_dir, use_sudo: use_sudo)
-
-        # Upload file
-        upload(file_path, remote_path, use_sudo: use_sudo)
-        uploaded_count += 1
-      end
+      uploaded_count = upload_files(
+        files_to_sync,
+        resolved_source,
+        destination,
+        parallel: parallel,
+        use_sudo: use_sudo
+      )
 
       # Delete extra files if requested
       deleted_count = 0
@@ -196,6 +204,80 @@ module Kdeploy
       end
     end
 
+    def sync_with_rsync(source, destination, ignore:, exclude:, delete:, use_sudo:)
+      return nil unless system('command -v rsync >/dev/null 2>&1')
+
+      exclude_file = build_rsync_excludes(ignore + exclude)
+
+      unless remote_rsync_available?
+        File.delete(exclude_file) if exclude_file && File.exist?(exclude_file)
+        return nil
+      end
+
+      begin
+        rsync_cmd = build_rsync_command(source, destination, exclude_file, delete: delete, use_sudo: use_sudo)
+        return nil unless system(rsync_cmd)
+
+        {
+          uploaded: 0,
+          deleted: 0,
+          total: 0,
+          fast_path: 'rsync'
+        }
+      ensure
+        File.delete(exclude_file) if exclude_file && File.exist?(exclude_file)
+      end
+    rescue StandardError
+      nil
+    end
+
+    def build_rsync_excludes(patterns)
+      patterns = Array(patterns).compact
+      return nil if patterns.empty?
+
+      file = Tempfile.new('kdeploy_rsync_excludes')
+      patterns.each { |pattern| file.write("#{pattern}\n") }
+      file.close
+      file.path
+    end
+
+    def build_rsync_command(source, destination, exclude_file, delete:, use_sudo:)
+      delete_flag = delete ? '--delete' : ''
+      exclude_flag = exclude_file ? "--exclude-from='#{exclude_file}'" : ''
+      ssh_cmd = build_rsync_ssh_command
+      sudo_flag = if use_sudo || requires_sudo?(destination)
+                    '--rsync-path="sudo rsync"'
+                  else
+                    ''
+                  end
+      parts = [
+        'rsync -az',
+        delete_flag,
+        exclude_flag,
+        sudo_flag,
+        "-e \"#{ssh_cmd}\"",
+        "#{Shellwords.escape(source)}/",
+        "#{@user}@#{@ip}:#{Shellwords.escape(destination)}/"
+      ].reject(&:empty?)
+      parts.join(' ')
+    end
+
+    def build_rsync_ssh_command
+      ssh = ['ssh']
+      ssh << "-p #{@port}" if @port
+      ssh << "-i #{Shellwords.escape(@key)}" if @key
+      ssh.join(' ')
+    end
+
+    def remote_rsync_available?
+      Net::SSH.start(@ip, @user, ssh_options) do |ssh|
+        output = ssh.exec!('command -v rsync 2>/dev/null || true')
+        return !output.to_s.strip.empty?
+      end
+    rescue StandardError
+      false
+    end
+
     def requires_sudo?(path)
       # Check if path is in system directories that typically require sudo
       system_dirs = %w[/etc /usr /var /opt /sbin /bin /lib /lib64 /root]
@@ -229,16 +311,16 @@ module Kdeploy
     end
 
     def wrap_with_sudo(command)
-      # 如果命令已经以 sudo 开头，不重复添加
+      # Do not add sudo again if command already starts with sudo
       return command if command.strip.start_with?('sudo')
 
-      # 多行、shell 控制结构、或包含 && / || / ; 的复合命令需整段在 sudo 下执行
+      # Wrap multi-line/control/compound commands so sudo applies to the full block
       needs_wrap = command.include?("\n") ||
                    command.match?(/\b(if|for|while|case|function)\b/) ||
                    command.match?(/\s(&&|\|\||;)\s/)
 
       if needs_wrap
-        # 转义命令中的单引号，然后用 bash -c 执行
+        # Escape single quotes in command, then execute via bash -c
         escaped_command = command.gsub("'", "'\"'\"'")
         if @sudo_password
           escaped_password = @sudo_password.gsub('\'', "'\"'\"'").gsub('$', '\\$').gsub('`', '\\`')
@@ -247,7 +329,7 @@ module Kdeploy
           "sudo bash -c '#{escaped_command}'"
         end
       elsif @sudo_password
-        # 单行命令直接包装
+        # Wrap single-line command directly
         escaped_password = @sudo_password.gsub('\'', "'\"'\"'").gsub('$', '\\$').gsub('`', '\\`')
         "echo '#{escaped_password}' | sudo -S #{command}"
       else
@@ -271,6 +353,55 @@ module Kdeploy
       files
     end
 
+    def upload_files(files_to_sync, source_dir, destination, parallel:, use_sudo:)
+      count = Concurrent::AtomicFixnum.new(0)
+      source_path = Pathname.new(source_dir)
+      parallel = normalize_parallel(parallel)
+      return upload_files_sequential(files_to_sync, source_path, destination, use_sudo, count) if parallel <= 1
+
+      queue = Queue.new
+      files_to_sync.each { |path| queue << path }
+      workers = Array.new(parallel) do
+        Thread.new do
+          until queue.empty?
+            file_path = begin
+              queue.pop(true)
+            rescue StandardError
+              nil
+            end
+            next unless file_path
+
+            upload_single_file(file_path, source_path, destination, use_sudo)
+            count.increment
+          end
+        end
+      end
+      workers.each(&:join)
+      count.value
+    end
+
+    def upload_files_sequential(files_to_sync, source_path, destination, use_sudo, count)
+      files_to_sync.each do |file_path|
+        upload_single_file(file_path, source_path, destination, use_sudo)
+        count.increment
+      end
+      count.value
+    end
+
+    def upload_single_file(file_path, source_path, destination, use_sudo)
+      relative_path = Pathname.new(file_path).relative_path_from(source_path).to_s
+      remote_path = File.join(destination, relative_path).gsub(%r{/+}, '/')
+      remote_dir = File.dirname(remote_path)
+      ensure_remote_directory(remote_dir, use_sudo: use_sudo)
+      upload(file_path, remote_path, use_sudo: use_sudo)
+    end
+
+    def normalize_parallel(parallel)
+      value = parallel.nil? ? Configuration.default_sync_parallel : parallel
+      value = value.to_i
+      value.positive? ? value : 1
+    end
+
     def ensure_remote_directory(remote_dir, use_sudo: nil)
       use_sudo = @use_sudo if use_sudo.nil?
       return if remote_dir.nil? || remote_dir.empty? || remote_dir == '.' || remote_dir == '/'

data/lib/kdeploy/{output_formatter.rb → output/output_formatter.rb}

@@ -18,7 +18,6 @@ module Kdeploy
     def format_host_status(host, status)
       status_str = case status
                    when :success then @pastel.green('✓ ok')
-                   when :changed then @pastel.yellow('~ changed')
                    else @pastel.red('✗ failed')
                    end
       @pastel.bright_white("  #{host.ljust(20)} #{status_str}")
@@ -101,21 +100,18 @@ module Kdeploy
     end
 
     def calculate_summary_counts(result)
-      ok = %i[success changed].include?(result[:status]) ? result[:output].size : 0
+      ok = result[:status] == :success ? result[:output].size : 0
       failed = result[:status] == :failed ? 1 : 0
-      changed = result[:status] == :changed ? result[:output].size : 0
-      { ok: ok, failed: failed, changed: changed }
+      { ok: ok, failed: failed }
     end
 
     def build_summary_line(host, counts, max_host_len)
       ok_w = 7
-      changed_w = 11
       failed_w = 10
 
       ok_str = @pastel.green("ok=#{counts[:ok].to_s.ljust(ok_w - 3)}")
-      changed_str = @pastel.yellow("changed=#{counts[:changed].to_s.ljust(changed_w - 8)}")
       failed_str = @pastel.red("failed=#{counts[:failed].to_s.ljust(failed_w - 7)}")
-      "#{host.ljust(max_host_len)} : #{ok_str}  #{changed_str}  #{failed_str}"
+      "#{host.ljust(max_host_len)} : #{ok_str}  #{failed_str}"
     end
 
     def colorize_summary_line(line, counts)
@@ -261,6 +257,7 @@ module Kdeploy
       stats = []
       stats << @pastel.green("#{uploaded} uploaded") if uploaded.positive?
       stats << @pastel.yellow("#{deleted} deleted") if deleted.positive?
+      stats << @pastel.cyan("fast: #{result[:fast_path]}") if result[:fast_path]
       stats_str = stats.any? ? " (#{stats.join(', ')})" : " (#{total} files)"
 
       @pastel.dim('    ') + @pastel.cyan(display_path) + @pastel.dim(stats_str) + duration_str + " #{status_str}"

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

@@ -9,7 +9,9 @@ module Kdeploy
                    debug: false, base_dir: nil, retries: Configuration.default_retries,
                    retry_delay: Configuration.default_retry_delay,
                    retry_on_nonzero: Configuration.default_retry_on_nonzero,
-                   host_timeout: Configuration.default_host_timeout)
+                   host_timeout: Configuration.default_host_timeout,
+                   step_timeout: Configuration.default_step_timeout,
+                   retry_policy: Configuration.default_retry_policy)
       @hosts = hosts
       @tasks = tasks
       @parallel = parallel
@@ -20,6 +22,8 @@ module Kdeploy
       @retry_delay = retry_delay
       @retry_on_nonzero = retry_on_nonzero
       @host_timeout = normalize_timeout(host_timeout)
+      @step_timeout = normalize_timeout(step_timeout)
+      @retry_policy = retry_policy
       @pool = Concurrent::FixedThreadPool.new(@parallel)
       @results = Concurrent::Hash.new
     end
@@ -61,6 +65,7 @@ module Kdeploy
             pending.delete(future)
             progressed = true
           elsif timeout_exceeded?(started_at, now)
+            future.cancel if future.respond_to?(:cancel)
             @results[host_name] ||= {
               status: :failed,
               error: "execution timeout after #{@host_timeout}s",
@@ -102,7 +107,9 @@ module Kdeploy
         debug: @debug,
         retries: @retries,
         retry_delay: @retry_delay,
-        retry_on_nonzero: @retry_on_nonzero
+        retry_on_nonzero: @retry_on_nonzero,
+        step_timeout: @step_timeout,
+        retry_policy: @retry_policy
       )
       result = { status: :success, output: [] }
 

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

@@ -2,12 +2,14 @@
 
 require 'erb'
 require 'tempfile'
+require 'set'
 
 module Kdeploy
   # ERB template rendering and upload handler
   class Template
     def self.render(template_path, variables = {})
       template_content = File.read(template_path)
+      validate_template_variables(template_content, variables)
       context = create_template_context(variables)
       ERB.new(template_content).result(context.instance_eval { binding })
     end
@@ -24,17 +26,38 @@ module Kdeploy
     def self.render_and_upload(executor, template_path, destination, variables = {})
       rendered_content = render(template_path, variables)
 
-      # 创建临时文件
+      # Create temporary file
       temp_file = Tempfile.new('kdeploy')
       begin
         temp_file.write(rendered_content)
         temp_file.close
 
-        # 上传渲染后的文件
+        # Upload rendered file
         executor.upload(temp_file.path, destination)
       ensure
         temp_file.unlink
       end
     end
+
+    def self.validate_template_variables(template_content, variables)
+      required = extract_template_identifiers(template_content)
+      return if required.empty?
+
+      provided = variables.keys.to_set(&:to_s)
+      missing = required.reject { |name| provided.include?(name) }
+      return if missing.empty?
+
+      raise ArgumentError, "Missing template variables: #{missing.sort.join(', ')}"
+    end
+
+    def self.extract_template_identifiers(template_content)
+      identifiers = template_content.scan(/<%=\s*([a-zA-Z_]\w*)/).flatten
+      identifiers.uniq - ruby_keywords
+    end
+
+    def self.ruby_keywords
+      %w[alias and begin break case class def defined? do else elsif end ensure false for if in module next nil not
+         or redo rescue retry return self super then true undef unless until when while yield]
+    end
   end
 end

data/lib/kdeploy/version.rb

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

data/lib/kdeploy.rb

@@ -2,20 +2,20 @@
 
 require_relative 'kdeploy/version'
 require_relative 'kdeploy/errors'
-require_relative 'kdeploy/configuration'
-require_relative 'kdeploy/output'
+require_relative 'kdeploy/config/configuration'
+require_relative 'kdeploy/output/output'
 require_relative 'kdeploy/banner'
-require_relative 'kdeploy/file_filter'
-require_relative 'kdeploy/dsl'
-require_relative 'kdeploy/executor'
-require_relative 'kdeploy/command_executor'
-require_relative 'kdeploy/output_formatter'
-require_relative 'kdeploy/help_formatter'
-require_relative 'kdeploy/runner'
-require_relative 'kdeploy/initializer'
-require_relative 'kdeploy/template'
+require_relative 'kdeploy/executor/file_filter'
+require_relative 'kdeploy/dsl/dsl'
+require_relative 'kdeploy/executor/executor'
+require_relative 'kdeploy/executor/command_executor'
+require_relative 'kdeploy/output/output_formatter'
+require_relative 'kdeploy/cli/help_formatter'
+require_relative 'kdeploy/runner/runner'
+require_relative 'kdeploy/dsl/initializer'
+require_relative 'kdeploy/template/template'
 require_relative 'kdeploy/post_install'
-require_relative 'kdeploy/cli'
+require_relative 'kdeploy/cli/cli'
 
 # Kdeploy - A lightweight agentless deployment automation tool
 module Kdeploy

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.4
 platform: ruby
 authors:
 - Kk
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-03 00:00:00.000000000 Z
+date: 2026-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf
@@ -160,29 +160,28 @@ extensions:
 - ext/mkrf_conf.rb
 extra_rdoc_files: []
 files:
-- AGENTS.md
 - README.md
 - README_EN.md
 - exe/kdeploy
 - ext/mkrf_conf.rb
 - lib/kdeploy.rb
 - lib/kdeploy/banner.rb
-- lib/kdeploy/cli.rb
-- lib/kdeploy/command_executor.rb
+- lib/kdeploy/cli/cli.rb
+- lib/kdeploy/cli/help_formatter.rb
 - lib/kdeploy/completions/kdeploy.bash
 - lib/kdeploy/completions/kdeploy.zsh
-- lib/kdeploy/configuration.rb
-- lib/kdeploy/dsl.rb
+- lib/kdeploy/config/configuration.rb
+- lib/kdeploy/dsl/dsl.rb
+- lib/kdeploy/dsl/initializer.rb
 - lib/kdeploy/errors.rb
-- lib/kdeploy/executor.rb
-- lib/kdeploy/file_filter.rb
-- lib/kdeploy/help_formatter.rb
-- lib/kdeploy/initializer.rb
-- lib/kdeploy/output.rb
-- lib/kdeploy/output_formatter.rb
+- lib/kdeploy/executor/command_executor.rb
+- lib/kdeploy/executor/executor.rb
+- lib/kdeploy/executor/file_filter.rb
+- lib/kdeploy/output/output.rb
+- lib/kdeploy/output/output_formatter.rb
 - lib/kdeploy/post_install.rb
-- lib/kdeploy/runner.rb
-- lib/kdeploy/template.rb
+- lib/kdeploy/runner/runner.rb
+- lib/kdeploy/template/template.rb
 - lib/kdeploy/version.rb
 homepage: https://github.com/kevin197011/kdeploy
 licenses:

data/AGENTS.md

@@ -1,18 +0,0 @@
-<!-- OPENSPEC:START -->
-# OpenSpec Instructions
-
-These instructions are for AI assistants working in this project.
-
-Always open `@/openspec/AGENTS.md` when the request:
-- Mentions planning or proposals (words like proposal, spec, change, plan)
-- Introduces new capabilities, breaking changes, architecture shifts, or big performance/security work
-- Sounds ambiguous and you need the authoritative spec before coding
-
-Use `@/openspec/AGENTS.md` to learn:
-- How to create and apply change proposals
-- Spec format and conventions
-- Project structure and guidelines
-
-Keep this managed block so 'openspec update' can refresh the instructions.
-
-<!-- OPENSPEC:END -->

data/lib/kdeploy/command_executor.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-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)
-      @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)
-      cmd = command[:command]
-      use_sudo = command[:sudo]
-
-      result, duration = measure_time do
-        with_retries { @executor.execute(cmd, use_sudo: use_sudo) }
-      end
-
-      { command: cmd, output: result, duration: duration, type: :run }
-    end
-
-    def execute_upload(command, _host_name)
-      _result, duration = measure_time do
-        with_retries { @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)
-      _result, duration = measure_time do
-        with_retries do
-          @executor.upload_template(command[:source], command[:destination], command[:variables])
-        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]
-
-      result, duration = measure_time do
-        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)
-    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
-      attempts = 0
-      begin
-        attempts += 1
-        yield
-      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?
-        retry
-      end
-    end
-  end
-end