kdeploy 0.1.0 → 0.3.0

data/lib/kdeploy/dsl.rb

@@ -1,566 +1,102 @@
 # frozen_string_literal: true
 
 module Kdeploy
-  # Domain Specific Language for deployment scripts
-  class DSL
-    def initialize(script_dir = nil)
-      @pipeline = Pipeline.new
-      @current_task = nil
-      @inventory = nil
-      @script_dir = script_dir || Dir.pwd
-      @template_manager = nil
+  module DSL
+    def self.extended(base)
+      base.instance_variable_set(:@kdeploy_hosts, {})
+      base.instance_variable_set(:@kdeploy_tasks, {})
+      base.instance_variable_set(:@kdeploy_roles, {})
     end
 
-    # Get pipeline or set pipeline name
-    # @param name [String] Pipeline name (optional)
-    # @return [Pipeline] Pipeline instance
-    def pipeline(name = nil)
-      @pipeline.instance_variable_set(:@name, name) if name
-      @pipeline
+    def kdeploy_hosts
+      @kdeploy_hosts ||= {}
     end
 
-    # Set global variable
-    # @param key [String, Symbol] Variable key
-    # @param value [Object] Variable value
-    def set(key, value)
-      @pipeline.set_variable(key, value)
+    def kdeploy_tasks
+      @kdeploy_tasks ||= {}
     end
 
-    # Define host
-    # @param hostname [String] Hostname or IP address
-    # @param user [String] SSH user
-    # @param port [Integer] SSH port
-    # @param roles [Array] Host roles
-    # @param vars [Hash] Host variables
-    # @param ssh_options [Hash] SSH connection options
-    # @return [Host] Created host
-    def host(hostname, user: nil, port: nil, roles: [], vars: {}, **ssh_options)
-      @pipeline.add_host(
-        hostname,
-        user: user,
-        port: port,
-        roles: roles,
-        vars: vars,
-        ssh_options: ssh_options
-      )
+    def kdeploy_roles
+      @kdeploy_roles ||= {}
     end
 
-    # Define multiple hosts
-    # @param hosts_config [Hash] Hosts configuration
-    def hosts(hosts_config)
-      @pipeline.add_hosts(hosts_config)
+    def host(name, **options)
+      kdeploy_hosts[name] = options.merge(name: name)
     end
 
-    # Load hosts from inventory file
-    # @param inventory_file [String] Path to inventory file
-    def inventory(inventory_file = nil)
-      inventory_file ||= default_inventory_file
-      resolved_path = resolve_inventory_path(inventory_file)
-
-      return unless File.exist?(resolved_path)
-
-      load_inventory(resolved_path)
-    end
-
-    # Initialize template manager
-    # @param template_dir [String] Template directory path
-    def template_dir(template_dir = nil)
-      template_dir ||= default_template_dir
-      resolved_path = resolve_template_path(template_dir)
-
-      @template_manager = TemplateManager.new(resolved_path, @pipeline.variables)
-      KdeployLogger.info("Template directory set to: #{resolved_path}")
-    end
-
-    # Get or initialize template manager
-    # @return [TemplateManager] Template manager instance
-    def template_manager
-      @template_manager ||= begin
-        dir = default_template_dir
-        resolved_path = resolve_template_path(dir)
-        TemplateManager.new(resolved_path, @pipeline.variables)
-      end
-    end
-
-    # Define task
-    # @param name [String] Task name
-    # @param on [Array, Symbol] Target hosts or roles
-    # @param parallel [Boolean] Execute in parallel
-    # @param fail_fast [Boolean] Stop on first failure
-    # @param max_concurrent [Integer] Maximum concurrent executions
-    # @return [Task] Created task
-    def task(name, on: nil, parallel: true, fail_fast: false, max_concurrent: nil, &block)
-      target_hosts = resolve_target_hosts(on)
-
-      @current_task = @pipeline.add_task(
-        name,
-        hosts: target_hosts,
-        parallel: parallel,
-        fail_fast: fail_fast,
-        max_concurrent: max_concurrent
-      )
-
-      instance_eval(&block) if block
-      @current_task = nil
-    end
-
-    # Execute command in current task
-    # @param command [String] Command to execute (supports heredoc)
-    # @param name [String] Command name (optional)
-    # @param timeout [Integer] Command timeout
-    # @param retry_count [Integer] Number of retries
-    # @param retry_delay [Integer] Delay between retries
-    # @param ignore_errors [Boolean] Continue on error
-    # @param only [Array, Symbol] Run only on specified roles
-    # @param except [Array, Symbol] Skip specified roles
-    # @return [Array<Command>] Created commands
-    def run(command, name: nil, timeout: nil, retry_count: nil, retry_delay: nil,
-            ignore_errors: false, only: nil, except: nil)
-      raise 'run can only be called within a task block' unless @current_task
-
-      process_commands(command, name).each_with_object([]) do |(cmd_name, cmd), commands|
-        commands << add_command_to_task(
-          cmd_name, cmd, timeout, retry_count, retry_delay,
-          ignore_errors, only, except
-        )
-      end
-    end
-
-    # Execute local command
-    # @param command [String] Local command to execute
-    # @param name [String] Command name (optional)
-    # @return [Array<Hash>] Command results
-    def local(command, name: nil)
-      require 'open3'
-
-      process_commands(command, name).map do |cmd_name, cmd|
-        execute_local_command(cmd, cmd_name)
-      end
-    end
-
-    # Upload file to remote host
-    # @param local_path [String] Local file path
-    # @param remote_path [String] Remote file path
-    # @param name [String] Command name (optional)
-    # @return [Command] Created upload command
-    def upload(local_path, remote_path, name: nil)
-      raise 'upload can only be called within a task block' unless @current_task
-
-      ensure_remote_directory(remote_path)
-      command_name = name || "upload_#{File.basename(local_path)}"
-      add_upload_command(local_path, remote_path, command_name)
-    end
-
-    # Upload template to remote host
-    # @param template_name [String] Template name
-    # @param remote_path [String] Remote file path
-    # @param variables [Hash] Template variables
-    # @param name [String] Command name (optional)
-    # @return [Command] Created template upload command
-    def upload_template(template_name, remote_path, variables: {}, name: nil)
-      raise 'upload_template can only be called within a task block' unless @current_task
-
-      ensure_remote_directory(remote_path)
-      command_name = name || "upload_template_#{File.basename(template_name)}"
-      add_template_upload_command(template_name, remote_path, variables, command_name)
-    end
-
-    # Download file from remote host
-    # @param remote_path [String] Remote file path
-    # @param local_path [String] Local file path
-    # @param name [String] Command name (optional)
-    # @return [Command] Created download command
-    def download(remote_path, local_path, name: nil)
-      raise 'download can only be called within a task block' unless @current_task
-
-      command_name = name || "download_#{File.basename(remote_path)}"
-      add_download_command(remote_path, local_path, command_name)
-    end
-
-    # Get hosts by role
-    # @param role [String, Symbol] Role to filter by
-    # @return [Array<Host>] Hosts with specified role
-    def role(role)
-      @pipeline.hosts_with_role(role)
-    end
-
-    # Conditional execution
-    # @param condition [Boolean] Condition to check
-    # @yield Block to execute if condition is true
-    def when(condition, &)
-      instance_eval(&) if condition && block_given?
-    end
-
-    # Inverse conditional execution
-    # @param condition [Boolean] Condition to check
-    # @yield Block to execute if condition is false
-    def unless(condition, &)
-      instance_eval(&) if !condition && block_given?
+    def role(name, hosts)
+      kdeploy_roles[name] = hosts
     end
 
-    # Include external script
-    # @param script_path [String] Path to script file
-    def include(script_path)
-      return unless File.exist?(script_path)
-
-      script_content = File.read(script_path)
-      instance_eval(script_content, script_path)
-    end
-
-    private
-
-    def default_inventory_file
-      Kdeploy.configuration&.inventory_file || 'inventory.yml'
-    end
-
-    def resolve_inventory_path(inventory_file)
-      return inventory_file if File.absolute_path?(inventory_file)
-
-      File.join(@script_dir, inventory_file)
-    end
-
-    def load_inventory(inventory_file)
-      @inventory = Inventory.new(inventory_file)
-      add_inventory_hosts
-      set_inventory_variables
-      log_inventory_loaded(inventory_file)
-    end
-
-    def add_inventory_hosts
-      @inventory.all_hosts.each do |host|
-        @pipeline.hosts << host unless @pipeline.hosts.include?(host)
-      end
-    end
-
-    def set_inventory_variables
-      @inventory.vars.each do |key, value|
-        @pipeline.set_variable(key, value)
-      end
-    end
-
-    def log_inventory_loaded(inventory_file)
-      KdeployLogger.info(
-        "Loaded #{@inventory.hosts.size} hosts from inventory: #{inventory_file}"
-      )
-    end
-
-    def default_template_dir
-      Kdeploy.configuration&.template_dir || 'templates'
-    end
-
-    def resolve_template_path(template_dir)
-      return template_dir if File.absolute_path?(template_dir)
-
-      File.join(@script_dir, template_dir)
-    end
-
-    def process_commands(command, base_name)
-      commands = process_heredoc_command(command)
-      commands.each_with_index.map do |cmd, index|
-        cmd = cmd.strip
-        next if cmd.empty? || cmd.start_with?('#')
-
-        [generate_command_name(cmd, base_name, index, commands.size), cmd]
-      end.compact
-    end
-
-    def generate_command_name(cmd, base_name, index, total)
-      return base_name if base_name && total == 1
-
-      prefix = base_name || (cmd.split.first || 'unnamed')
-      total > 1 ? "#{prefix}_#{index + 1}" : prefix
-    end
-
-    def add_command_to_task(name, cmd, timeout, retry_count, retry_delay,
-                            ignore_errors, only, except)
-      @current_task.add_command(
-        name,
-        cmd,
-        timeout: timeout,
-        retry_count: retry_count,
-        retry_delay: retry_delay,
-        ignore_errors: ignore_errors,
-        only: only,
-        except: except
-      )
-    end
-
-    def execute_local_command(cmd, name)
-      processed_cmd = process_local_command_variables(cmd)
-      start_time = Time.now
-
-      log_local_command_start(name, processed_cmd)
-      stdout, stderr, status = Open3.capture3(processed_cmd)
-      duration = Time.now - start_time
-
-      handle_local_command_result(name, duration, status.exitstatus, stdout, stderr)
-    end
-
-    def process_local_command_variables(cmd)
-      processed_cmd = cmd.dup
-      @pipeline.variables.each do |key, value|
-        processed_cmd.gsub!(/\$\{#{key}\}/, value.to_s)
-      end
-      processed_cmd
-    end
-
-    def log_local_command_start(name, cmd)
-      KdeployLogger.info("🚀 Executing local command '#{name}'")
-      KdeployLogger.debug("Command: #{cmd}")
-    end
-
-    def handle_local_command_result(name, duration, exit_code, stdout, stderr)
-      if exit_code.zero?
-        log_local_command_success(name, duration, stdout)
-      else
-        log_local_command_failure(name, duration, exit_code, stdout, stderr)
-      end
-
-      {
-        name: name,
-        success: exit_code.zero?,
-        duration: duration,
-        exit_code: exit_code,
-        stdout: stdout,
-        stderr: stderr
+    def task(name, on: nil, roles: nil, &block)
+      kdeploy_tasks[name] = {
+        hosts: if on.is_a?(Array)
+                 on
+               else
+                 (on ? [on] : nil)
+               end,
+        roles: if roles.is_a?(Array)
+                 roles
+               else
+                 (roles ? [roles] : nil)
+               end,
+        block: lambda {
+          @kdeploy_commands = []
+          instance_eval(&block)
+          @kdeploy_commands
+        }
       }
     end
 
-    def log_local_command_success(name, duration, stdout)
-      KdeployLogger.info("✅ Local command '#{name}' completed in #{duration.round(2)}s")
-      KdeployLogger.debug("Output: #{stdout}") unless stdout.strip.empty?
-    end
-
-    def log_local_command_failure(name, duration, exit_code, stdout, stderr)
-      KdeployLogger.error("❌ Local command '#{name}' failed in #{duration.round(2)}s (exit code: #{exit_code})")
-      KdeployLogger.error("STDERR: #{stderr}") unless stderr.empty?
-      KdeployLogger.error("STDOUT: #{stdout}") unless stdout.strip.empty?
-    end
-
-    def ensure_remote_directory(remote_path)
-      run("mkdir -p #{File.dirname(remote_path)}", name: 'create directory')
-    end
-
-    def add_upload_command(local_path, remote_path, _command_name)
-      upload_command = UploadCommand.new(local_path, remote_path, @pipeline.variables)
-      @current_task.commands << upload_command
-      upload_command
+    def run(command)
+      @kdeploy_commands ||= []
+      @kdeploy_commands << { type: :run, command: command }
     end
 
-    def add_template_upload_command(template_name, remote_path, variables, _command_name)
-      command = TemplateUploadCommand.new(
-        template_name,
-        remote_path,
-        variables,
-        template_manager,
-        @pipeline.variables
-      )
-      @current_task.commands << command
-      command
+    def upload(source, destination)
+      @kdeploy_commands ||= []
+      @kdeploy_commands << { type: :upload, source: source, destination: destination }
     end
 
-    def add_download_command(remote_path, local_path, _command_name)
-      command = DownloadCommand.new(remote_path, local_path, @pipeline.variables)
-      @current_task.commands << command
-      command
-    end
-
-    def resolve_target_hosts(target)
-      return @pipeline.hosts if target.nil?
-
-      Array(target).flat_map { |t| resolve_single_target(t) }.uniq
-    end
-
-    def resolve_single_target(target)
-      case target
-      when Host
-        target
-      when Symbol
-        @pipeline.hosts_with_role(target)
-      when String
-        resolve_host_by_name(target) || @pipeline.hosts_with_role(target.to_sym)
-      when Array
-        target.flat_map { |t| resolve_single_target(t) }
-      else
-        []
-      end
-    end
-
-    def resolve_host_by_name(name)
-      host = @pipeline.hosts.find { |h| h.hostname == name }
-      [host] if host
-    end
-
-    def process_heredoc_command(command)
-      command.split(/\r?\n/)
-    end
-  end
-
-  # Command class for file upload operations
-  class UploadCommand < Command
-    def initialize(local_path, remote_path, global_variables = {})
-      @local_path = local_path
-      @remote_path = remote_path
-      @global_variables = global_variables
-      super()
-    end
-
-    def execute(host, connection)
-      start_time = Time.now
-      processed_path = process_remote_path(host)
-
-      begin
-        connection.upload(@local_path, processed_path)
-        record_success(start_time, host)
-      rescue StandardError => e
-        record_failure(e, start_time, host)
-        raise
-      end
-    end
-
-    private
-
-    def process_remote_path(host)
-      path = @remote_path.dup
-      variables = @global_variables.merge(host.vars)
-      variables.each do |key, value|
-        path.gsub!(/\$\{#{key}\}/, value.to_s)
-      end
-      path
-    end
-
-    def record_success(start_time, host)
-      duration = Time.now - start_time
-      KdeployLogger.info("✅ Uploaded #{@local_path} to #{host.hostname}:#{@remote_path} in #{duration.round(2)}s")
-    end
-
-    def record_failure(error, start_time, host)
-      duration = Time.now - start_time
-      KdeployLogger.error("❌ Failed to upload #{@local_path} to #{host.hostname}:#{@remote_path} in #{duration.round(2)}s")
-      KdeployLogger.error("Error: #{error.message}")
-    end
-  end
-
-  # Command class for file download operations
-  class DownloadCommand < Command
-    def initialize(remote_path, local_path, global_variables = {})
-      @remote_path = remote_path
-      @local_path = local_path
-      @global_variables = global_variables
-      super()
-    end
-
-    def execute(host, connection)
-      start_time = Time.now
-      processed_path = process_remote_path(host)
-
-      begin
-        connection.download(processed_path, @local_path)
-        record_success(start_time, host)
-      rescue StandardError => e
-        record_failure(e, start_time, host)
-        raise
-      end
-    end
-
-    private
-
-    def process_remote_path(host)
-      path = @remote_path.dup
-      variables = @global_variables.merge(host.vars)
-      variables.each do |key, value|
-        path.gsub!(/\$\{#{key}\}/, value.to_s)
-      end
-      path
-    end
-
-    def record_success(start_time, host)
-      duration = Time.now - start_time
-      KdeployLogger.info("✅ Downloaded #{host.hostname}:#{@remote_path} to #{@local_path} in #{duration.round(2)}s")
+    def upload_template(source, destination, variables = {})
+      @kdeploy_commands ||= []
+      @kdeploy_commands << {
+        type: :upload_template,
+        source: source,
+        destination: destination,
+        variables: variables
+      }
     end
 
-    def record_failure(error, start_time, host)
-      duration = Time.now - start_time
-      KdeployLogger.error("❌ Failed to download #{host.hostname}:#{@remote_path} to #{@local_path} in #{duration.round(2)}s")
-      KdeployLogger.error("Error: #{error.message}")
+    def inventory(&)
+      instance_eval(&) if block_given?
     end
-  end
 
-  # Command class for template upload operations
-  class TemplateUploadCommand < Command
-    def initialize(template_name, remote_path, variables, template_manager, global_variables = {})
-      @template_name = template_name
-      @remote_path = remote_path
-      @variables = variables
-      @template_manager = template_manager
-      @global_variables = global_variables
-      super()
-    end
+    def get_task_hosts(task_name)
+      task = kdeploy_tasks[task_name]
+      return kdeploy_hosts.keys if !task || (!task[:hosts] && !task[:roles])
 
-    def execute(host, connection)
-      start_time = Time.now
-      host_variables = build_host_variables(host)
-      processed_path = process_remote_path_variables(host_variables)
+      hosts = Set.new
 
-      begin
-        perform_template_upload(host, connection, host_variables, processed_path)
-        record_success(start_time, host)
-      rescue StandardError => e
-        record_failure(e, start_time, host)
-        raise
+      # 添加指定的主机
+      if task[:hosts]
+        task[:hosts].each do |host|
+          hosts.add(host) if kdeploy_hosts.key?(host)
+        end
       end
-    end
 
-    private
+      # 添加角色中的主机
+      if task[:roles]
+        task[:roles].each do |role|
+          next unless role_hosts = kdeploy_roles[role]
 
-    def build_host_variables(host)
-      @global_variables.merge(@variables).merge(host.vars).merge(
-        hostname: host.hostname,
-        user: host.user,
-        port: host.port
-      )
-    end
-
-    def process_remote_path_variables(host_variables)
-      path = @remote_path.dup
-      host_variables.each do |key, value|
-        path.gsub!(/\$\{#{key}\}/, value.to_s)
+          role_hosts.each do |host|
+            hosts.add(host) if kdeploy_hosts.key?(host)
+          end
+        end
       end
-      path
-    end
-
-    def perform_template_upload(_host, connection, host_variables, processed_path)
-      rendered_content = @template_manager.render(@template_name, host_variables)
-      temp_file = create_temp_file(rendered_content)
-      upload_template_file(connection, temp_file, processed_path)
-    ensure
-      cleanup_temp_file(temp_file) if temp_file
-    end
-
-    def create_temp_file(content)
-      temp_file = "/tmp/kdeploy_template_#{Time.now.to_i}_#{Process.pid}"
-      File.write(temp_file, content)
-      temp_file
-    end
-
-    def upload_template_file(connection, temp_file, processed_path)
-      connection.execute("mkdir -p #{File.dirname(processed_path)}")
-      connection.upload(temp_file, processed_path)
-    end
-
-    def cleanup_temp_file(temp_file)
-      FileUtils.rm_f(temp_file)
-    end
-
-    def record_success(start_time, host)
-      duration = Time.now - start_time
-      KdeployLogger.info("✅ Uploaded template #{@template_name} to #{host.hostname}:#{@remote_path} in #{duration.round(2)}s")
-    end
 
-    def record_failure(error, start_time, host)
-      duration = Time.now - start_time
-      KdeployLogger.error("❌ Failed to upload template #{@template_name} to #{host.hostname}:#{@remote_path} in #{duration.round(2)}s")
-      KdeployLogger.error("Error: #{error.message}")
+      hosts.to_a
     end
   end
 end

data/lib/kdeploy/executor.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'net/ssh'
+require 'net/scp'
+
+module Kdeploy
+  class Executor
+    def initialize(host_config)
+      @host = host_config[:name]
+      @user = host_config[:user]
+      @ip = host_config[:ip]
+      @password = host_config[:password]
+      @key = host_config[:key]
+    end
+
+    def execute(command)
+      Net::SSH.start(@ip, @user, ssh_options) do |ssh|
+        stdout = String.new
+        stderr = String.new
+
+        ssh.exec!(command) do |_channel, stream, data|
+          case stream
+          when :stdout
+            stdout << data
+          when :stderr
+            stderr << data
+          end
+        end
+
+        {
+          stdout: stdout.strip,
+          stderr: stderr.strip,
+          command: command
+        }
+      end
+    rescue Net::SSH::AuthenticationFailed => e
+      raise "SSH authentication failed: #{e.message}"
+    rescue StandardError => e
+      raise "SSH execution failed: #{e.message}"
+    end
+
+    def upload(source, destination)
+      Net::SCP.start(@ip, @user, ssh_options) do |scp|
+        scp.upload!(source, destination)
+      end
+    rescue StandardError => e
+      raise "SCP upload failed: #{e.message}"
+    end
+
+    def upload_template(source, destination, variables = {})
+      Template.render_and_upload(self, source, destination, variables)
+    rescue StandardError => e
+      raise "Template upload failed: #{e.message}"
+    end
+
+    private
+
+    def ssh_options
+      options = {
+        verify_host_key: :never,
+        timeout: 30
+      }
+
+      if @password
+        options[:password] = @password
+      elsif @key
+        options[:keys] = [@key]
+      end
+
+      options
+    end
+  end
+end