kdeploy 0.2.0 → 0.3.0

data/lib/kdeploy/initializer.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+module Kdeploy
+  class Initializer
+    def initialize(target_dir = '.')
+      @target_dir = File.expand_path(target_dir)
+    end
+
+    def run
+      create_directory_structure
+      create_deploy_file
+      create_config_files
+      create_readme
+      show_success_message
+    end
+
+    private
+
+    def create_directory_structure
+      FileUtils.mkdir_p(@target_dir) unless @target_dir == '.'
+      FileUtils.mkdir_p(File.join(@target_dir, 'config'))
+    end
+
+    def create_deploy_file
+      File.write(File.join(@target_dir, 'deploy.rb'), <<~RUBY)
+        # frozen_string_literal: true
+
+        # Define hosts
+        host "web01", user: "ubuntu", ip: "10.0.0.1", key: "~/.ssh/id_rsa"
+        host "web02", user: "ubuntu", ip: "10.0.0.2", key: "~/.ssh/id_rsa"
+
+        # Define roles
+        role :web, %w[web01 web02]
+        role :db, %w[db01]
+
+        # Define inventory
+        inventory do
+          host "db01", user: "root", ip: "10.0.0.3", key: "~/.ssh/id_rsa"
+        end
+
+        # Define deployment task for web servers
+        task :deploy_web, roles: :web do
+          # Stop service
+          run "sudo systemctl stop nginx"
+
+          # Upload configuration using ERB template
+          upload_template "./config/nginx.conf.erb", "/etc/nginx/nginx.conf",
+            domain_name: "example.com",
+            port: 3000,
+            worker_processes: 4,
+            worker_connections: 2048
+
+          # Upload static configuration
+          upload "./config/app.conf", "/etc/nginx/conf.d/app.conf"
+
+          # Restart service
+          run "sudo systemctl start nginx"
+
+          # Check status
+          run "sudo systemctl status nginx"
+        end
+
+        # Define backup task for database servers
+        task :backup_db, roles: :db do
+          run "tar -czf /tmp/backup.tar.gz /var/lib/postgresql/data"
+          run "aws s3 cp /tmp/backup.tar.gz s3://my-backups/"
+          run "rm /tmp/backup.tar.gz"
+        end
+
+        # Define task for specific hosts
+        task :maintenance, on: %w[web01] do
+          run "sudo systemctl stop nginx"
+          run "sudo apt-get update && sudo apt-get upgrade -y"
+          run "sudo systemctl start nginx"
+        end
+
+        # Define task for all hosts
+        task :update do
+          run "sudo apt-get update && sudo apt-get upgrade -y"
+        end
+      RUBY
+    end
+
+    def create_config_files
+      # 创建配置目录
+      config_dir = File.join(@target_dir, 'config')
+      FileUtils.mkdir_p(config_dir)
+
+      # 创建 Nginx ERB 模板
+      File.write(File.join(config_dir, 'nginx.conf.erb'), <<~CONF)
+        user nginx;
+        worker_processes <%= worker_processes %>;
+        error_log /var/log/nginx/error.log;
+        pid /run/nginx.pid;
+
+        events {
+            worker_connections <%= worker_connections %>;
+        }
+
+        http {
+            include /etc/nginx/mime.types;
+            default_type application/octet-stream;
+
+            log_format main '$remote_addr - $remote_user [$time_local] "$request" '
+                          '$status $body_bytes_sent "$http_referer" '
+                          '"$http_user_agent" "$http_x_forwarded_for"';
+
+            access_log /var/log/nginx/access.log main;
+
+            sendfile on;
+            tcp_nopush on;
+            tcp_nodelay on;
+            keepalive_timeout 65;
+            types_hash_max_size 2048;
+
+            upstream app_servers {
+                server 127.0.0.1:<%= port %>;
+            }
+
+            server {
+                listen 80;
+                server_name <%= domain_name %>;
+
+                location / {
+                    proxy_pass http://app_servers;
+                    proxy_http_version 1.1;
+                    proxy_set_header Upgrade $http_upgrade;
+                    proxy_set_header Connection 'upgrade';
+                    proxy_set_header Host $host;
+                    proxy_cache_bypass $http_upgrade;
+                }
+
+                error_page 500 502 503 504 /50x.html;
+                location = /50x.html {
+                    root /usr/share/nginx/html;
+                }
+            }
+        }
+      CONF
+
+      # 创建静态配置文件示例
+      File.write(File.join(config_dir, 'app.conf'), <<~CONF)
+        location /api {
+            proxy_pass http://localhost:3000;
+            proxy_http_version 1.1;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection 'upgrade';
+            proxy_set_header Host $host;
+            proxy_cache_bypass $http_upgrade;
+        }
+      CONF
+    end
+
+    def create_readme
+      File.write(File.join(@target_dir, 'README.md'), <<~MD)
+        # Deployment Project
+
+        This is a deployment project created with Kdeploy.
+
+        ## Structure
+
+        ```
+        .
+        ├── deploy.rb           # Deployment tasks
+        ├── config/            # Configuration files
+        │   ├── nginx.conf.erb # Nginx configuration template
+        │   └── app.conf      # Static configuration
+        └── README.md         # This file
+        ```
+
+        ## Configuration Templates
+
+        The project uses ERB templates for dynamic configuration. For example, in `nginx.conf.erb`:
+
+        ```erb
+        worker_processes <%= worker_processes %>;
+        server_name <%= domain_name %>;
+        ```
+
+        Variables are passed when uploading the template:
+
+        ```ruby
+        upload_template "./config/nginx.conf.erb", "/etc/nginx/nginx.conf",
+          domain_name: "example.com",
+          worker_processes: 4
+        ```
+
+        ## Usage
+
+        ```bash
+        # Show what would be done
+        kdeploy execute deploy.rb --dry-run
+
+        # Deploy to web servers
+        kdeploy execute deploy.rb deploy_web
+
+        # Backup database
+        kdeploy execute deploy.rb backup_db
+
+        # Run maintenance on web01
+        kdeploy execute deploy.rb maintenance
+
+        # Update all hosts
+        kdeploy execute deploy.rb update
+
+        # Deploy to specific hosts
+        kdeploy execute deploy.rb deploy_web --limit web01,web02
+        ```
+      MD
+    end
+
+    def show_success_message
+      pastel = Pastel.new
+      puts Kdeploy::Banner.show_success("Project initialized in #{@target_dir}")
+      puts <<~INFO
+        #{pastel.bright_white('Created files:')}
+        #{pastel.dim("  #{File.join(@target_dir, 'deploy.rb')}")}
+        #{pastel.dim("  #{File.join(@target_dir, 'config/nginx.conf.erb')}")}
+        #{pastel.dim("  #{File.join(@target_dir, 'config/app.conf')}")}
+        #{pastel.dim("  #{File.join(@target_dir, 'README.md')}")}
+
+        #{pastel.bright_white('Try running:')}
+        #{pastel.bright_cyan("  kdeploy execute #{File.join(@target_dir, 'deploy.rb')} deploy_web --dry-run")}
+      INFO
+    end
+  end
+end

data/lib/kdeploy/runner.rb

@@ -1,190 +1,50 @@
 # frozen_string_literal: true
 
+require 'concurrent'
+
 module Kdeploy
   class Runner
-    attr_reader :pipeline
-
-    def initialize(pipeline)
-      @pipeline = pipeline
-    end
-
-    # Execute the deployment pipeline
-    # @return [Hash] Execution results
-    def execute
-      validate_pipeline!
-      setup_logging
-
-      KdeployLogger.info("Starting deployment: #{@pipeline.name}")
-      KdeployLogger.info("Pipeline summary: #{@pipeline.summary}")
-
-      start_time = Time.now
-
-      begin
-        result = @pipeline.execute
-
-        duration = Time.now - start_time
-
-        # Enhanced result with pipeline info for statistics
-        enhanced_result = result.merge(
-          pipeline_name: @pipeline.name,
-          hosts_count: @pipeline.hosts.size
-        )
-
-        # Record deployment statistics
-        Kdeploy.statistics.record_deployment(enhanced_result)
-
-        log_final_results(enhanced_result, duration)
-
-        enhanced_result
-      rescue StandardError => e
-        duration = Time.now - start_time
-        KdeployLogger.fatal("Deployment failed after #{duration.round(2)}s: #{e.message}")
-        KdeployLogger.debug("Error backtrace: #{e.backtrace.join("\n")}")
-
-        failed_result = {
-          success: false,
-          error: e.message,
-          duration: duration,
-          results: [],
-          pipeline_name: @pipeline.name,
-          hosts_count: @pipeline.hosts.size,
-          tasks_count: @pipeline.tasks.size,
-          success_count: 0
-        }
-
-        # Record failed deployment statistics
-        Kdeploy.statistics.record_deployment(failed_result)
-
-        failed_result
-      end
-    end
-
-    # Dry run - validate and show what would be executed
-    # @return [Hash] Validation results and execution plan
-    def dry_run
-      KdeployLogger.info("Performing dry run for pipeline: #{@pipeline.name}")
-
-      validation_errors = @pipeline.validate
-
-      if validation_errors.any?
-        KdeployLogger.error('Pipeline validation failed:')
-        validation_errors.each { |error| KdeployLogger.error("  - #{error}") }
-
-        return {
-          success: false,
-          validation_errors: validation_errors,
-          execution_plan: nil
-        }
-      end
-
-      execution_plan = generate_execution_plan
-
-      KdeployLogger.info('Dry run completed successfully')
-      log_execution_plan(execution_plan)
-
-      {
-        success: true,
-        validation_errors: [],
-        execution_plan: execution_plan
-      }
-    end
-
-    private
-
-    def validate_pipeline!
-      validation_errors = @pipeline.validate
-
-      return if validation_errors.empty?
-
-      error_message = "Pipeline validation failed:\n#{validation_errors.map { |e| "  - #{e}" }.join("\n")}"
-      raise ConfigurationError, error_message
-    end
-
-    def setup_logging
-      config = Kdeploy.configuration
-      return unless config
-
-      KdeployLogger.setup(
-        level: config.log_level,
-        file: config.log_file
-      )
-    end
-
-    def log_final_results(result, duration)
-      if result[:success]
-        KdeployLogger.info("✅ Deployment completed successfully in #{duration.round(2)}s")
-        KdeployLogger.info("📊 Summary: #{result[:success_count]}/#{result[:tasks_count]} tasks successful")
-      else
-        KdeployLogger.error("❌ Deployment failed in #{duration.round(2)}s")
-        KdeployLogger.error("📊 Summary: #{result[:success_count]}/#{result[:tasks_count]} tasks successful")
-      end
-
-      # Log task details
-      if result[:results].is_a?(Array)
-        result[:results].each do |task_result|
-          status = task_result[:success] ? '✅' : '❌'
-          success_info = "#{task_result[:success_count]}/#{task_result[:hosts_count]} hosts successful"
-          KdeployLogger.info("#{status} Task '#{task_result[:task_name]}': #{success_info}")
+    def initialize(hosts, tasks, parallel: 5)
+      @hosts = hosts
+      @tasks = tasks
+      @parallel = parallel
+      @pool = Concurrent::FixedThreadPool.new(@parallel)
+      @results = Concurrent::Hash.new
+    end
+
+    def run(task_name)
+      task = @tasks[task_name]
+      raise "Task not found: #{task_name}" unless task
+
+      futures = @hosts.map do |name, config|
+        Concurrent::Future.execute(executor: @pool) do
+          executor = Executor.new(config)
+          result = { status: :success, output: [] }
+
+          task[:block].call.each do |command|
+            case command[:type]
+            when :run
+              output = executor.execute(command[:command])
+              result[:output] << { command: command[:command], output: output }
+            when :upload
+              executor.upload(command[:source], command[:destination])
+              result[:output] << { command: "upload: #{command[:source]} -> #{command[:destination]}" }
+            when :upload_template
+              executor.upload_template(command[:source], command[:destination], command[:variables])
+              result[:output] << { command: "upload_template: #{command[:source]} -> #{command[:destination]}" }
+            end
+          end
+
+          @results[name] = result
+        rescue StandardError => e
+          @results[name] = { status: :failed, error: e.message }
         end
       end
 
-      # Log statistics summary
-      global_stats = Kdeploy.statistics.global_summary
-      KdeployLogger.info("📈 Global Stats: #{global_stats[:total_deployments]} deployments, " \
-                         "#{global_stats[:successful_deployments]} successful, " \
-                         "#{global_stats[:failed_deployments]} failed")
-    end
-
-    def generate_execution_plan
-      plan = {
-        pipeline_name: @pipeline.name,
-        total_hosts: @pipeline.hosts.size,
-        total_tasks: @pipeline.tasks.size,
-        hosts: @pipeline.hosts.map(&:hostname),
-        tasks: []
-      }
-
-      @pipeline.tasks.each do |task|
-        task_plan = {
-          name: task.name,
-          target_hosts: task.hosts.map(&:hostname),
-          commands: task.commands.map do |command|
-            {
-              name: command.name,
-              command: command.command,
-              options: command.options
-            }
-          end,
-          options: task.options
-        }
-
-        plan[:tasks] << task_plan
-      end
-
-      plan
-    end
-
-    def log_execution_plan(plan)
-      KdeployLogger.info('📋 Execution Plan:')
-      KdeployLogger.info("  Pipeline: #{plan[:pipeline_name]}")
-      KdeployLogger.info("  Hosts: #{plan[:total_hosts]} (#{plan[:hosts].join(', ')})")
-      KdeployLogger.info("  Tasks: #{plan[:total_tasks]}")
-
-      plan[:tasks].each_with_index do |task, index|
-        KdeployLogger.info("    #{index + 1}. #{task[:name]}")
-        KdeployLogger.info("       Targets: #{task[:target_hosts].join(', ')}")
-        KdeployLogger.info("       Commands: #{task[:commands].size}")
-
-        task[:commands].each_with_index do |command, cmd_index|
-          KdeployLogger.info("         #{cmd_index + 1}. #{command[:name]}: #{command[:command]}")
-        end
-
-        if task[:options][:parallel]
-          KdeployLogger.info("       Execution: Parallel (max: #{task[:options][:max_concurrent] || 'unlimited'})")
-        else
-          KdeployLogger.info('       Execution: Sequential')
-        end
-      end
+      futures.each(&:wait)
+      @results
+    ensure
+      @pool.shutdown
     end
   end
 end

data/lib/kdeploy/template.rb

@@ -1,173 +1,30 @@
 # frozen_string_literal: true
 
+require 'erb'
+require 'ostruct'
+
 module Kdeploy
-  # ERB template management class
   class Template
-    attr_reader :path, :content, :variables
-
-    def initialize(template_path, variables = {})
-      @path = template_path
-      @variables = variables
-      @content = load_template
-    end
-
-    # Render template with variables
-    # @param additional_vars [Hash] Additional variables to merge
-    # @return [String] Rendered content
-    def render(additional_vars = {})
-      all_vars = @variables.merge(additional_vars)
-
-      # Create binding with variables
-      template_binding = create_binding(all_vars)
-
-      # Render ERB template
-      erb = ERB.new(@content, trim_mode: '-')
-      erb.result(template_binding)
-    rescue StandardError => e
-      raise TemplateError, "Failed to render template #{@path}: #{e.message}"
+    def self.render(template_path, variables = {})
+      template_content = File.read(template_path)
+      context = OpenStruct.new(variables)
+      ERB.new(template_content).result(context.instance_eval { binding })
     end
 
-    # Render and save to file
-    # @param output_path [String] Output file path
-    # @param additional_vars [Hash] Additional variables
-    def render_to_file(output_path, additional_vars = {})
-      rendered_content = render(additional_vars)
+    def self.render_and_upload(executor, template_path, destination, variables = {})
+      rendered_content = render(template_path, variables)
 
-      # Ensure output directory exists
-      FileUtils.mkdir_p(File.dirname(output_path))
+      # 创建临时文件
+      temp_file = Tempfile.new('kdeploy')
+      begin
+        temp_file.write(rendered_content)
+        temp_file.close
 
-      # Write rendered content
-      File.write(output_path, rendered_content)
-
-      KdeployLogger.info("Template rendered to: #{output_path}")
-      output_path
-    end
-
-    # Check if template file exists
-    # @return [Boolean] True if template exists
-    def exist?
-      File.exist?(@path)
-    end
-
-    # Get template modification time
-    # @return [Time] Template file mtime
-    def mtime
-      File.mtime(@path) if exist?
-    end
-
-    private
-
-    # Load template content from file
-    # @return [String] Template content
-    def load_template
-      raise TemplateError, "Template file not found: #{@path}" unless File.exist?(@path)
-
-      File.read(@path)
-    rescue StandardError => e
-      raise TemplateError, "Failed to load template #{@path}: #{e.message}"
-    end
-
-    # Create binding with variables
-    # @param vars [Hash] Variables hash
-    # @return [Binding] Binding object with variables
-    def create_binding(vars)
-      # Create a clean binding
-      template_binding = binding
-
-      # Define variables in the binding
-      vars.each do |key, value|
-        template_binding.local_variable_set(key.to_sym, value)
+        # 上传渲染后的文件
+        executor.upload(temp_file.path, destination)
+      ensure
+        temp_file.unlink
       end
-
-      # Define helper methods
-      template_binding.local_variable_set(:hostname, vars[:hostname] || vars['hostname'])
-      template_binding.local_variable_set(:user, vars[:user] || vars['user'])
-      template_binding.local_variable_set(:port, vars[:port] || vars['port'])
-
-      template_binding
     end
   end
-
-  # Template manager for handling multiple templates
-  class TemplateManager
-    attr_reader :template_dir, :global_variables
-
-    def initialize(template_dir = 'templates', global_variables = {})
-      @template_dir = template_dir
-      @global_variables = global_variables
-      @templates = {}
-    end
-
-    # Load template by name
-    # @param template_name [String] Template name (without .erb extension)
-    # @param variables [Hash] Template variables
-    # @return [Template] Template object
-    def load_template(template_name, variables = {})
-      template_path = resolve_template_path(template_name)
-      all_variables = @global_variables.merge(variables)
-
-      @templates[template_name] = Template.new(template_path, all_variables)
-    end
-
-    # Render template by name
-    # @param template_name [String] Template name
-    # @param variables [Hash] Additional variables
-    # @return [String] Rendered content
-    def render(template_name, variables = {})
-      template = @templates[template_name] || load_template(template_name, variables)
-      template.render(variables)
-    end
-
-    # Render template to file
-    # @param template_name [String] Template name
-    # @param output_path [String] Output file path
-    # @param variables [Hash] Additional variables
-    # @return [String] Output file path
-    def render_to_file(template_name, output_path, variables = {})
-      template = @templates[template_name] || load_template(template_name, variables)
-      template.render_to_file(output_path, variables)
-    end
-
-    # List available templates
-    # @return [Array<String>] Template names
-    def list_templates
-      return [] unless Dir.exist?(@template_dir)
-
-      Dir.glob("#{@template_dir}/**/*.erb").map do |path|
-        File.basename(path, '.erb')
-      end
-    end
-
-    # Set global variables
-    # @param variables [Hash] Global variables
-    def global_variables=(variables)
-      @global_variables.merge!(variables)
-    end
-
-    private
-
-    # Resolve template file path
-    # @param template_name [String] Template name
-    # @return [String] Full template path
-    def resolve_template_path(template_name)
-      # Add .erb extension if not present
-      template_name += '.erb' unless template_name.end_with?('.erb')
-
-      # Try template directory first
-      template_path = File.join(@template_dir, template_name)
-      return template_path if File.exist?(template_path)
-
-      # Try relative to current directory
-      return template_name if File.exist?(template_name)
-
-      # Try absolute path
-      return template_name if File.absolute_path?(template_name) && File.exist?(template_name)
-
-      # Default to template directory path (will be checked by Template class)
-      template_path
-    end
-  end
-
-  # Template-related errors
-  class TemplateError < StandardError; end
 end

data/lib/kdeploy/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 module Kdeploy
-  # Current version of Kdeploy
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end