kdeploy 1.2.23 → 1.2.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dfa0bbbf5f65674369359fb3d6d642e0d13069a09a3977fd207a82bb684becd
-  data.tar.gz: 4205c885219c2f649bb20f21b94b2a3065efa49a7b7362f2242f4d6acee20646
+  metadata.gz: 6e6d5731024f6c6038b668226945d6360dcd2e6abab1e68a54872b0e815bacd0
+  data.tar.gz: 9c8505220dfb4999a9fa62a8607428b880b7bd954c7ecc9707b6dd5a72c65e25
 SHA512:
-  metadata.gz: 35e6042bb30288a4a9357a1fab9755b5481696649ad2f9d2ca58f33e287cb378541ae463da110d731de1d9c8b39d9e674305e037ff94f2e492ef655aa166ffa8
-  data.tar.gz: 5a196211a257f939299c46fca4c2b3e6c58105d3756ab9ba59b6551d8b08c439186bc971fc1ef971b171fae55fb416f25ff48ed6d6edf05061181d239f3d9fcb
+  metadata.gz: aa53413eb0414244474a7f1e838074ecdefa34ae7e146a7711abb04317babdeb1ae6b1492a5f33c2357fb311ab58657f19e4155eace3ad045e338f2b3891938b
+  data.tar.gz: 26d4cd0add001ff1877f8fdc013f6ee89b9eb0d1fe6951cc197d202167613c9f69e85d8af10512cce08d7c76cdec1de5b208e2f595b4bb15a7a9754ecd680e4d

data/README.md

@@ -9,7 +9,7 @@
                 |_|            |___/
 
 ⚡ 轻量级无代理部署工具
-🚀 自信部署，轻松扩展
+🚀 自动部署，轻松扩展
 ```
 
 一个用 Ruby 编写的轻量级、无代理的部署自动化工具。Kdeploy 使您能够使用 SSH 在多个服务器上部署应用程序、管理配置和执行任务，而无需在目标机器上安装任何代理或守护进程。
@@ -44,6 +44,7 @@
 - 📝 **优雅的 Ruby DSL**: 简单而富有表现力的任务定义语法
 - 🚀 **并发执行**: 跨多个主机的高效并行任务处理
 - 📤 **文件上传支持**: 通过 SCP 轻松部署文件和模板
+- 📁 **目录同步功能**: 递归同步目录，支持文件过滤和删除多余文件
 - 📊 **任务状态跟踪**: 实时执行监控，提供详细输出
 - 🔄 **ERB 模板支持**: 支持变量替换的动态配置生成
 - 🎯 **基于角色的部署**: 针对特定服务器角色进行有组织的部署
@@ -472,6 +473,48 @@ upload_template "./config/nginx.conf.erb", "/etc/nginx/nginx.conf",
 - `destination`: 远程文件路径
 - `variables`: 用于模板渲染的变量哈希
 
+#### `sync` - 同步目录
+
+递归同步本地目录到远程服务器，支持文件过滤和删除多余文件。
+
+```ruby
+# 基本同步
+sync "./app", "/var/www/app"
+
+# 同步并忽略特定文件/目录
+sync "./app", "/var/www/app",
+  ignore: [".git", "*.log", "node_modules", "*.tmp"]
+
+# 同步并删除远程多余文件
+sync "./app", "/var/www/app",
+  ignore: [".git", "*.log"],
+  delete: true
+
+# 排除特定文件（与 ignore 相同，但语义更清晰）
+sync "./config", "/etc/app",
+  exclude: ["*.example", "*.bak", ".env.local"]
+```
+
+**参数:**
+- `source`: 本地源目录路径
+- `destination`: 远程目标目录路径
+- `ignore`: 要忽略的文件/目录模式数组（支持 .gitignore 风格的通配符）
+- `exclude`: 与 `ignore` 相同，用于语义清晰
+- `delete`: 布尔值，是否删除远程目录中不存在于源目录的文件（默认: false）
+
+**忽略模式支持:**
+- `*.log` - 匹配所有 .log 文件
+- `node_modules` - 匹配 node_modules 目录或文件
+- `**/*.tmp` - 递归匹配所有 .tmp 文件
+- `.git` - 匹配 .git 目录
+- `config/*.local` - 匹配 config 目录下的所有 .local 文件
+
+**使用场景:**
+- 部署应用程序代码
+- 同步配置文件目录
+- 同步静态资源文件
+- 保持本地和远程目录结构一致
+
 ### 模板支持
 
 Kdeploy 支持 ERB（嵌入式 Ruby）模板，用于动态配置生成。
@@ -1005,6 +1048,23 @@ task :update_config, roles: :web do
 end
 ```
 
+#### 目录同步部署
+
+```ruby
+task :deploy_app, roles: :web do
+  # 同步应用程序代码，忽略开发文件
+  sync "./app", "/var/www/app",
+    ignore: [".git", "*.log", "node_modules", ".env.local", "*.tmp"],
+    delete: true
+
+  # 同步配置文件
+  sync "./config", "/etc/app",
+    exclude: ["*.example", "*.bak"]
+
+  run "sudo systemctl restart app"
+end
+```
+
 ## 📝 许可证
 
 该 gem 在 [MIT 许可证](https://opensource.org/licenses/MIT) 条款下作为开源提供。

data/lib/kdeploy/cli.rb

@@ -162,6 +162,8 @@ module Kdeploy
         formatter.format_upload_steps(steps, shown)
       when :upload_template
         formatter.format_template_steps(steps, shown)
+      when :sync
+        formatter.format_sync_steps(steps, shown)
       when :run
         formatter.format_run_steps(steps, shown)
       else

data/lib/kdeploy/command_executor.rb

@@ -53,6 +53,38 @@ module Kdeploy
       }
     end
 
+    def execute_sync(command, host_name)
+      source = command[:source]
+      destination = command[:destination]
+      ignore = command[:ignore] || []
+      exclude = command[:exclude] || []
+      delete = command[:delete] || false
+
+      description = "sync: #{source} -> #{destination}"
+      description += " (delete: #{delete})" if delete
+      show_command_header(host_name, :sync, description)
+
+      result, duration = measure_time do
+        @executor.sync_directory(
+          source,
+          destination,
+          ignore: ignore,
+          exclude: exclude,
+          delete: delete
+        )
+      end
+
+      {
+        command: "sync: #{source} -> #{destination}",
+        duration: duration,
+        type: :sync,
+        result: result,
+        uploaded: result[:uploaded],
+        deleted: result[:deleted],
+        total: result[:total]
+      }
+    end
+
     private
 
     def measure_time

data/lib/kdeploy/command_grouper.rb

@@ -13,6 +13,8 @@ module Kdeploy
       case cmd[:type]
       when :upload, :upload_template
         "#{cmd[:type]}_#{cmd[:source]}"
+      when :sync
+        "#{cmd[:type]}_#{cmd[:source]}"
       when :run
         "#{cmd[:type]}_#{cmd[:command].to_s.lines.first.strip}"
       else
@@ -26,6 +28,8 @@ module Kdeploy
         "upload #{command[:source]}"
       when :upload_template
         "template #{command[:source]}"
+      when :sync
+        "sync #{command[:source]}"
       when :run
         command[:command].to_s.lines.first.strip
       else

data/lib/kdeploy/dsl.rb

@@ -39,6 +39,44 @@ module Kdeploy
       }
     end
 
+    # Assign task to roles or hosts after task definition
+    def assign_task(task_name, on: nil, roles: nil)
+      task = kdeploy_tasks[task_name.to_sym]
+      raise ArgumentError, "Task #{task_name} not found" unless task
+
+      task[:hosts] = normalize_hosts_option(on) if on
+      task[:roles] = normalize_roles_option(roles) if roles
+    end
+
+    # Include task file and automatically assign all tasks to specified roles or hosts
+    def include_tasks(file_path, roles: nil, on: nil)
+      # Resolve relative paths based on the caller's file location
+      unless File.absolute_path?(file_path)
+        caller_file = caller_locations(1, 1).first.path
+        base_dir = File.dirname(File.expand_path(caller_file))
+        file_path = File.expand_path(file_path, base_dir)
+      end
+
+      # Store tasks before loading
+      tasks_before = kdeploy_tasks.keys
+
+      # Load the task file
+      module_eval(File.read(file_path), file_path)
+
+      # Get newly added tasks
+      tasks_after = kdeploy_tasks.keys
+      new_tasks = tasks_after - tasks_before
+
+      # Assign roles/hosts to all new tasks (only if task doesn't already have hosts/roles)
+      new_tasks.each do |task_name|
+        task = kdeploy_tasks[task_name]
+        # Only assign if task doesn't already have hosts or roles defined
+        next if task[:hosts] || task[:roles]
+
+        assign_task(task_name, roles: roles, on: on) if roles || on
+      end
+    end
+
     def normalize_hosts_option(on)
       return on if on.is_a?(Array)
 
@@ -83,6 +121,18 @@ module Kdeploy
       }
     end
 
+    def sync(source, destination, ignore: [], delete: false, exclude: [])
+      @kdeploy_commands ||= []
+      @kdeploy_commands << {
+        type: :sync,
+        source: source,
+        destination: destination,
+        ignore: Array(ignore),
+        exclude: Array(exclude),
+        delete: delete
+      }
+    end
+
     def inventory(&block)
       instance_eval(&block) if block_given?
     end

data/lib/kdeploy/executor.rb

@@ -3,6 +3,9 @@
 require 'net/ssh'
 require 'net/scp'
 require 'pathname'
+require 'find'
+require 'shellwords'
+require_relative 'file_filter'
 
 module Kdeploy
   # SSH/SCP executor for remote command execution and file operations
@@ -91,6 +94,51 @@ module Kdeploy
       raise TemplateError.new("Template upload failed: #{e.message}", e)
     end
 
+    def sync_directory(source, destination, ignore: [], exclude: [], delete: false, use_sudo: nil)
+      use_sudo = @use_sudo if use_sudo.nil?
+
+      # Resolve relative paths relative to base_dir
+      resolved_source = resolve_path(source)
+
+      # Validate source directory
+      raise FileNotFoundError, "Source directory not found: #{resolved_source}" unless File.directory?(resolved_source)
+
+      # Create file filter
+      all_patterns = ignore + exclude
+      filter = FileFilter.new(ignore_patterns: all_patterns)
+
+      # 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
+
+      # Delete extra files if requested
+      deleted_count = 0
+      deleted_count = delete_extra_files(resolved_source, destination, filter, use_sudo: use_sudo) if delete
+
+      {
+        uploaded: uploaded_count,
+        deleted: deleted_count,
+        total: files_to_sync.size
+      }
+    rescue StandardError => e
+      raise SCPError.new("Directory sync failed: #{e.message}", e)
+    end
+
     private
 
     def upload_with_sudo(source, destination)
@@ -184,5 +232,67 @@ module Kdeploy
         "sudo #{command}"
       end
     end
+
+    def collect_files_to_sync(source_dir, filter)
+      files = []
+      source_path = Pathname.new(source_dir)
+
+      Find.find(source_dir) do |file_path|
+        next if File.directory?(file_path)
+
+        relative_path = Pathname.new(file_path).relative_path_from(source_path).to_s
+        next if filter.ignored?(relative_path, source_dir)
+
+        files << file_path
+      end
+
+      files
+    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 == '/'
+
+      # Create directory with -p flag to create parent directories
+      mkdir_command = "mkdir -p #{remote_dir.shellescape}"
+      execute(mkdir_command, use_sudo: use_sudo)
+    rescue StandardError => e
+      # Ignore errors if directory already exists
+      error_msg = e.message.downcase
+      unless error_msg.include?('exists') || error_msg.include?('file exists') || error_msg.include?('already exists')
+        raise
+      end
+    end
+
+    def delete_extra_files(source_dir, destination_dir, filter, use_sudo: nil)
+      use_sudo = @use_sudo if use_sudo.nil?
+
+      # Get list of remote files
+      list_command = "find #{destination_dir.shellescape} -type f 2>/dev/null || true"
+      result = execute(list_command, use_sudo: use_sudo)
+      remote_files = result[:stdout].lines.map(&:strip).reject(&:empty?)
+
+      # Get list of local files (relative paths)
+      source_path = Pathname.new(source_dir)
+      local_files = collect_files_to_sync(source_dir, filter).map do |file_path|
+        relative_path = Pathname.new(file_path).relative_path_from(source_path).to_s
+        File.join(destination_dir, relative_path).gsub(%r{/+}, '/')
+      end
+
+      # Find files to delete
+      files_to_delete = remote_files - local_files
+
+      # Delete extra files
+      deleted_count = 0
+      files_to_delete.each do |file_path|
+        delete_command = "rm -f #{file_path.shellescape}"
+        execute(delete_command, use_sudo: use_sudo)
+        deleted_count += 1
+      rescue StandardError
+        # Ignore deletion errors
+      end
+
+      deleted_count
+    end
   end
 end

data/lib/kdeploy/file_filter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Kdeploy
+  # File filter for directory synchronization
+  # Supports .gitignore-style patterns
+  class FileFilter
+    def initialize(ignore_patterns: [])
+      @ignore_patterns = normalize_patterns(ignore_patterns)
+    end
+
+    # Check if a file should be ignored
+    def ignored?(file_path, base_path = nil)
+      relative_path = relative_path_for(file_path, base_path)
+      @ignore_patterns.any? { |pattern| match_pattern?(pattern, relative_path) }
+    end
+
+    # Filter files from a directory
+    def filter_files(files, base_path = nil)
+      files.reject { |file| ignored?(file, base_path) }
+    end
+
+    private
+
+    def normalize_patterns(patterns)
+      patterns.map do |pattern|
+        normalize_pattern(pattern)
+      end
+    end
+
+    def normalize_pattern(pattern)
+      # Remove leading slash if present (patterns are relative to base)
+      pattern = pattern.sub(%r{\A/}, '')
+      # Convert to regex
+      pattern_to_regex(pattern)
+    end
+
+    def pattern_to_regex(pattern)
+      # Convert .gitignore-style pattern to regex
+      regex_str = pattern
+                  .gsub('.', '\.') # Escape dots
+                  .gsub('**', '__STAR_STAR__') # Temporarily replace **
+                  .gsub('*', '[^/]*') # * matches anything except /
+                  .gsub('__STAR_STAR__', '.*') # ** matches anything including /
+                  .gsub('?', '[^/]')         # ? matches single char except /
+                  .gsub('[!', '[^')          # [^...] negation
+                  .gsub('[', '[')            # Character class
+
+      # Anchor to start if pattern doesn't start with **
+      regex_str = "^#{regex_str}" unless pattern.start_with?('**')
+      # Match end of string or directory separator
+      regex_str = "#{regex_str}(/|$)" unless pattern.end_with?('*') || pattern.end_with?('**')
+
+      Regexp.new(regex_str)
+    end
+
+    def match_pattern?(pattern, file_path)
+      return false if file_path.nil? || file_path.empty?
+
+      pattern.match?(file_path)
+    end
+
+    def relative_path_for(file_path, base_path)
+      return file_path.to_s unless base_path
+
+      base = Pathname.new(base_path)
+      file = Pathname.new(file_path)
+      file.relative_path_from(base).to_s
+    end
+  end
+end

data/lib/kdeploy/initializer.rb

@@ -88,6 +88,18 @@ module Kdeploy
             sudo apt-get update && sudo apt-get upgrade -y
           SHELL
         end
+
+        # Example: Directory synchronization task
+        task :sync_app, roles: :web do
+          # Sync application directory, ignoring development files
+          sync './app', '/var/www/app',
+            ignore: ['.git', '*.log', 'node_modules', '.env.local', '*.tmp'],
+            delete: true
+
+          # Sync configuration files
+          sync './config', '/etc/app',
+            exclude: ['*.example', '*.bak']
+        end
       RUBY
     end
 
@@ -262,6 +274,11 @@ module Kdeploy
           ```bash
           kdeploy execute deploy.rb update
           ```
+
+        - **sync_app**: Sync application directory to remote servers
+          ```bash
+          kdeploy execute deploy.rb sync_app
+          ```
       MD
     end
 

data/lib/kdeploy/output_formatter.rb

@@ -32,6 +32,17 @@ module Kdeploy
       format_file_steps(steps, shown, :upload_template, @pastel.yellow('  === Template ==='), 'upload_template: ')
     end
 
+    def format_sync_steps(steps, shown)
+      output = []
+      steps.each do |step|
+        next if step_already_shown?(step, :sync, shown)
+
+        mark_step_as_shown(step, :sync, shown)
+        output << format_sync_step(step)
+      end
+      output
+    end
+
     def format_file_steps(steps, shown, type, _header, prefix)
       output = []
       steps.each do |step|
@@ -154,6 +165,10 @@ module Kdeploy
         "#{@pastel.blue('>')} Upload: #{command[:source]} -> #{command[:destination]}"
       when :upload_template
         "#{@pastel.blue('>')} Template: #{command[:source]} -> #{command[:destination]}"
+      when :sync
+        ignore_str = command[:ignore]&.any? ? " (ignore: #{command[:ignore].join(', ')})" : ''
+        delete_str = command[:delete] ? ' (delete: true)' : ''
+        "#{@pastel.blue('>')} Sync: #{command[:source]} -> #{command[:destination]}#{ignore_str}#{delete_str}"
       else
         "#{@pastel.blue('>')} #{command[:type]}: #{command}"
       end
@@ -234,5 +249,24 @@ module Kdeploy
       key = [step[:command], type].hash
       shown[key] = true
     end
+
+    def format_sync_step(step)
+      duration_str = format_duration(step[:duration])
+      sync_path = step[:command].sub('sync: ', '')
+      # Truncate long paths for cleaner output
+      display_path = sync_path.length > 50 ? "...#{sync_path[-47..]}" : sync_path
+
+      result = step[:result] || {}
+      uploaded = result[:uploaded] || 0
+      deleted = result[:deleted] || 0
+      total = result[:total] || 0
+
+      stats = []
+      stats << @pastel.green("#{uploaded} uploaded") if uploaded.positive?
+      stats << @pastel.yellow("#{deleted} deleted") if deleted.positive?
+      stats_str = stats.any? ? " (#{stats.join(', ')})" : " (#{total} files)"
+
+      @pastel.dim('    📁 ') + @pastel.cyan(display_path) + @pastel.dim(stats_str) + duration_str
+    end
   end
 end

data/lib/kdeploy/runner.rb

@@ -162,6 +162,8 @@ module Kdeploy
         command_executor.execute_upload(command, host_name)
       when :upload_template
         command_executor.execute_upload_template(command, host_name)
+      when :sync
+        command_executor.execute_sync(command, host_name)
       else
         raise ConfigurationError, "Unknown command type: #{command[:type]}"
       end

data/lib/kdeploy/version.rb

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

data/lib/kdeploy.rb

@@ -5,6 +5,7 @@ require_relative 'kdeploy/errors'
 require_relative 'kdeploy/configuration'
 require_relative 'kdeploy/output'
 require_relative 'kdeploy/banner'
+require_relative 'kdeploy/file_filter'
 require_relative 'kdeploy/dsl'
 require_relative 'kdeploy/executor'
 require_relative 'kdeploy/command_grouper'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kdeploy
 version: !ruby/object:Gem::Version
-  version: 1.2.23
+  version: 1.2.28
 platform: ruby
 authors:
 - Kk
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-19 00:00:00.000000000 Z
+date: 2025-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bcrypt_pbkdf
@@ -175,6 +175,7 @@ files:
 - lib/kdeploy/dsl.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