kdeploy 0.1.0

data/lib/kdeploy/statistics.rb

@@ -0,0 +1,439 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  # Handles deployment statistics collection and analysis
+  class Statistics
+    attr_reader :data
+
+    def initialize(stats_file: nil)
+      @stats_file = stats_file || default_stats_file
+      @data = load_statistics
+      @session_start_time = Time.now
+    end
+
+    # Record a deployment execution
+    # @param result [Hash] Deployment result
+    def record_deployment(result)
+      deployment_data = build_deployment_data(result)
+      @data[:deployments] << deployment_data
+      update_global_stats(deployment_data)
+      save_statistics
+    end
+
+    # Record a task execution
+    # @param task_name [String] Task name
+    # @param result [Hash] Task execution result
+    def record_task(task_name, result)
+      task_data = build_task_data(task_name, result)
+      @data[:tasks] << task_data
+      update_task_stats(task_data)
+      save_statistics
+    end
+
+    # Record a command execution
+    # @param command_name [String] Command name
+    # @param host [String] Target host
+    # @param success [Boolean] Execution success
+    # @param duration [Float] Execution duration
+    def record_command(command_name, host, success, duration)
+      command_data = build_command_data(command_name, host, success, duration)
+      @data[:commands] << command_data
+      update_command_stats(command_data)
+      save_statistics
+    end
+
+    # Get deployment statistics summary
+    # @param days [Integer] Number of days to include (default: 30)
+    # @return [Hash] Statistics summary
+    def deployment_summary(days: 30)
+      cutoff_time = calculate_cutoff_time(days)
+      recent_deployments = filter_recent_data(@data[:deployments], cutoff_time)
+
+      return empty_summary if recent_deployments.empty?
+
+      build_deployment_summary(recent_deployments, days)
+    end
+
+    # Get task statistics summary
+    # @param days [Integer] Number of days to include (default: 30)
+    # @return [Hash] Task statistics summary
+    def task_summary(days: 30)
+      cutoff_time = calculate_cutoff_time(days)
+      recent_tasks = filter_recent_data(@data[:tasks], cutoff_time)
+
+      return empty_task_summary(days) if recent_tasks.empty?
+
+      build_task_summary(recent_tasks, days)
+    end
+
+    # Get global statistics
+    # @return [Hash] Global statistics
+    def global_summary
+      {
+        total_deployments: @data[:global][:deployments][:total],
+        successful_deployments: @data[:global][:deployments][:successful],
+        failed_deployments: @data[:global][:deployments][:failed],
+        total_tasks: @data[:global][:tasks][:total],
+        successful_tasks: @data[:global][:tasks][:successful],
+        failed_tasks: @data[:global][:tasks][:failed],
+        total_commands: @data[:global][:commands][:total],
+        successful_commands: @data[:global][:commands][:successful],
+        failed_commands: @data[:global][:commands][:failed],
+        total_execution_time: @data[:global][:total_execution_time].round(2),
+        session_start_time: @session_start_time,
+        session_duration: (Time.now - @session_start_time).round(2)
+      }
+    end
+
+    # Get top failed tasks
+    # @param limit [Integer] Number of tasks to return
+    # @param days [Integer] Number of days to include
+    # @return [Array] Top failed tasks
+    def top_failed_tasks(limit: 10, days: 30)
+      cutoff_time = calculate_cutoff_time(days)
+      recent_tasks = filter_recent_failed_tasks(cutoff_time)
+
+      build_top_failed_tasks(recent_tasks, limit)
+    end
+
+    # Get performance trends
+    # @param days [Integer] Number of days to analyze
+    # @return [Hash] Performance trends
+    def performance_trends(days: 7)
+      cutoff_time = calculate_cutoff_time(days)
+      recent_deployments = filter_recent_data(@data[:deployments], cutoff_time)
+
+      return { period_days: days, trends: {} } if recent_deployments.empty?
+
+      build_performance_trends(recent_deployments, days)
+    end
+
+    # Clear all statistics
+    def clear_statistics!
+      @data = default_statistics_structure
+      save_statistics
+    end
+
+    # Export statistics to file
+    # @param file_path [String] Export file path
+    # @param format [Symbol] Export format (:json, :csv)
+    def export_statistics(file_path, format: :json)
+      case format
+      when :json
+        export_to_json(file_path)
+      when :csv
+        export_to_csv(file_path)
+      else
+        raise ArgumentError, "Unsupported export format: #{format}"
+      end
+    end
+
+    private
+
+    def default_stats_file
+      File.join(Dir.home, '.kdeploy', 'statistics.json')
+    end
+
+    def load_statistics
+      return default_statistics_structure unless File.exist?(@stats_file)
+
+      begin
+        JSON.parse(File.read(@stats_file), symbolize_names: true)
+      rescue JSON::ParserError, StandardError
+        KdeployLogger.warn('Failed to load statistics file, creating new one')
+        default_statistics_structure
+      end
+    end
+
+    def save_statistics
+      FileUtils.mkdir_p(File.dirname(@stats_file))
+      File.write(@stats_file, JSON.pretty_generate(@data))
+    rescue StandardError => e
+      KdeployLogger.error("Failed to save statistics: #{e.message}")
+    end
+
+    def build_deployment_data(result)
+      {
+        timestamp: Time.now.to_f,
+        success: result[:success],
+        duration: result[:duration],
+        tasks_count: result[:tasks_count] || 0,
+        success_count: result[:success_count] || 0,
+        pipeline_name: result[:pipeline_name] || 'unknown',
+        hosts_count: result[:hosts_count] || 0
+      }
+    end
+
+    def build_task_data(task_name, result)
+      {
+        timestamp: Time.now.to_f,
+        name: task_name,
+        success: result[:success],
+        duration: result[:duration],
+        hosts_count: result[:hosts_count] || 0,
+        success_count: result[:success_count] || 0
+      }
+    end
+
+    def build_command_data(command_name, host, success, duration)
+      {
+        timestamp: Time.now.to_f,
+        name: command_name,
+        host: host,
+        success: success,
+        duration: duration
+      }
+    end
+
+    def calculate_cutoff_time(days)
+      Time.now - (days * 24 * 60 * 60)
+    end
+
+    def filter_recent_data(data, cutoff_time)
+      data.select { |d| d[:timestamp] >= cutoff_time.to_f }
+    end
+
+    def filter_recent_failed_tasks(cutoff_time)
+      @data[:tasks].select { |t| t[:timestamp] >= cutoff_time.to_f && !t[:success] }
+    end
+
+    def build_deployment_summary(deployments, days)
+      successful = deployments.count { |d| d[:success] }
+      failed = deployments.size - successful
+      durations = deployments.map { |d| d[:duration] }
+
+      {
+        period_days: days,
+        total_deployments: deployments.size,
+        successful_deployments: successful,
+        failed_deployments: failed,
+        success_rate: calculate_success_rate(successful, deployments.size),
+        avg_duration: calculate_average(durations),
+        min_duration: durations.min&.round(2),
+        max_duration: durations.max&.round(2),
+        total_duration: durations.sum.round(2)
+      }
+    end
+
+    def build_task_summary(tasks, days)
+      task_groups = tasks.group_by { |t| t[:name] }
+      task_stats = build_task_group_stats(task_groups)
+
+      {
+        period_days: days,
+        total_task_executions: tasks.size,
+        unique_tasks: task_groups.size,
+        tasks: task_stats
+      }
+    end
+
+    def build_task_group_stats(task_groups)
+      task_groups.transform_values do |tasks|
+        successful = tasks.count { |t| t[:success] }
+        failed = tasks.size - successful
+        durations = tasks.map { |t| t[:duration] }
+
+        {
+          total_executions: tasks.size,
+          successful: successful,
+          failed: failed,
+          success_rate: calculate_success_rate(successful, tasks.size),
+          avg_duration: calculate_average(durations),
+          total_duration: durations.sum.round(2)
+        }
+      end
+    end
+
+    def build_top_failed_tasks(tasks, limit)
+      failure_counts = calculate_failure_counts(tasks)
+      failure_counts.take(limit).map do |task_name, count|
+        last_failure = find_last_failure(tasks, task_name)
+        {
+          name: task_name,
+          failure_count: count,
+          last_failure_time: Time.at(last_failure[:timestamp]).utc,
+          last_failure_duration: last_failure[:duration].round(2)
+        }
+      end
+    end
+
+    def calculate_failure_counts(tasks)
+      tasks.group_by { |t| t[:name] }
+        .transform_values(&:size)
+        .sort_by { |_, count| -count }
+    end
+
+    def find_last_failure(tasks, task_name)
+      tasks.select { |t| t[:name] == task_name }
+        .max_by { |t| t[:timestamp] }
+    end
+
+    def build_performance_trends(deployments, days)
+      daily_stats = group_by_day(deployments)
+      trends = calculate_daily_trends(daily_stats)
+
+      {
+        period_days: days,
+        trends: trends
+      }
+    end
+
+    def group_by_day(deployments)
+      deployments.group_by do |d|
+        Time.at(d[:timestamp]).utc.to_date
+      end
+    end
+
+    def calculate_daily_trends(daily_stats)
+      daily_stats.transform_values do |deployments|
+        successful = deployments.count { |d| d[:success] }
+        durations = deployments.map { |d| d[:duration] }
+
+        {
+          total: deployments.size,
+          successful: successful,
+          failed: deployments.size - successful,
+          success_rate: calculate_success_rate(successful, deployments.size),
+          avg_duration: calculate_average(durations),
+          total_duration: durations.sum.round(2)
+        }
+      end
+    end
+
+    def calculate_success_rate(successful, total)
+      (successful.to_f / total * 100).round(2)
+    end
+
+    def calculate_average(values)
+      values.empty? ? 0 : (values.sum / values.size).round(2)
+    end
+
+    def empty_summary
+      {
+        period_days: 0,
+        total_deployments: 0,
+        successful_deployments: 0,
+        failed_deployments: 0,
+        success_rate: 0,
+        avg_duration: 0,
+        min_duration: 0,
+        max_duration: 0,
+        total_duration: 0
+      }
+    end
+
+    def empty_task_summary(days)
+      {
+        period_days: days,
+        total_task_executions: 0,
+        unique_tasks: 0,
+        tasks: {}
+      }
+    end
+
+    def default_statistics_structure
+      {
+        deployments: [],
+        tasks: [],
+        commands: [],
+        global: {
+          deployments: { total: 0, successful: 0, failed: 0 },
+          tasks: { total: 0, successful: 0, failed: 0 },
+          commands: { total: 0, successful: 0, failed: 0 },
+          total_execution_time: 0
+        }
+      }
+    end
+
+    def update_global_stats(deployment_data)
+      @data[:global][:deployments][:total] += 1
+      if deployment_data[:success]
+        @data[:global][:deployments][:successful] += 1
+      else
+        @data[:global][:deployments][:failed] += 1
+      end
+      @data[:global][:total_execution_time] += deployment_data[:duration]
+    end
+
+    def update_task_stats(task_data)
+      @data[:global][:tasks][:total] += 1
+      if task_data[:success]
+        @data[:global][:tasks][:successful] += 1
+      else
+        @data[:global][:tasks][:failed] += 1
+      end
+      @data[:global][:total_execution_time] += task_data[:duration]
+    end
+
+    def update_command_stats(command_data)
+      @data[:global][:commands][:total] += 1
+      if command_data[:success]
+        @data[:global][:commands][:successful] += 1
+      else
+        @data[:global][:commands][:failed] += 1
+      end
+      @data[:global][:total_execution_time] += command_data[:duration]
+    end
+
+    def export_to_json(file_path)
+      File.write(file_path, JSON.pretty_generate(@data))
+    end
+
+    def export_to_csv(file_path)
+      require 'csv'
+
+      CSV.open(file_path, 'w') do |csv|
+        export_deployments_to_csv(csv)
+        csv << []
+        export_tasks_to_csv(csv)
+        csv << []
+        export_commands_to_csv(csv)
+      end
+    end
+
+    def export_deployments_to_csv(csv)
+      csv << ['Deployments']
+      csv << %w[Timestamp Success Duration TasksCount SuccessCount PipelineName HostsCount]
+      @data[:deployments].each do |d|
+        csv << [
+          Time.at(d[:timestamp]).utc,
+          d[:success],
+          d[:duration],
+          d[:tasks_count],
+          d[:success_count],
+          d[:pipeline_name],
+          d[:hosts_count]
+        ]
+      end
+    end
+
+    def export_tasks_to_csv(csv)
+      csv << ['Tasks']
+      csv << %w[Timestamp Name Success Duration HostsCount SuccessCount]
+      @data[:tasks].each do |t|
+        csv << [
+          Time.at(t[:timestamp]).utc,
+          t[:name],
+          t[:success],
+          t[:duration],
+          t[:hosts_count],
+          t[:success_count]
+        ]
+      end
+    end
+
+    def export_commands_to_csv(csv)
+      csv << ['Commands']
+      csv << %w[Timestamp Name Host Success Duration]
+      @data[:commands].each do |c|
+        csv << [
+          Time.at(c[:timestamp]).utc,
+          c[:name],
+          c[:host],
+          c[:success],
+          c[:duration]
+        ]
+      end
+    end
+  end
+end

data/lib/kdeploy/task.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Kdeploy
+  # Task class for managing command execution on hosts
+  class Task
+    attr_reader :name, :hosts, :commands, :options
+    attr_accessor :global_variables
+
+    def initialize(name, hosts = [], options = {})
+      @name = name
+      @hosts = Array(hosts)
+      @commands = []
+      @options = default_options.merge(options)
+      @global_variables = {}
+    end
+
+    # Add command to task
+    # @param name [String] Command name
+    # @param command [String] Command to execute
+    # @param options [Hash] Command options
+    # @return [Command] Created command
+    def add_command(name, command, options = {})
+      command_options = options.merge(global_variables: @global_variables)
+      cmd = Command.new(name, command, command_options)
+      @commands << cmd
+      cmd
+    end
+
+    # Add host to task
+    # @param host [Host] Host to add
+    # @return [Host] Added host
+    def add_host(host)
+      @hosts << host unless @hosts.include?(host)
+      host
+    end
+
+    # Remove host from task
+    # @param host [Host] Host to remove
+    # @return [Host, nil] Removed host or nil if not found
+    def remove_host(host)
+      @hosts.delete(host)
+    end
+
+    # Execute task on all hosts
+    # @return [Hash] Execution results
+    def execute
+      return empty_execution_result if @commands.empty? || @hosts.empty?
+
+      log_task_start
+      start_time = Time.now
+      results = execute_commands
+      duration = Time.now - start_time
+      success_count = count_successful_hosts(results)
+
+      log_task_completion(duration, success_count)
+      build_task_result(results, duration, success_count)
+    end
+
+    private
+
+    def default_options
+      {
+        parallel: true,
+        fail_fast: false,
+        max_concurrent: nil
+      }
+    end
+
+    def empty_execution_result
+      { success: true, results: {} }
+    end
+
+    def log_task_start
+      KdeployLogger.info("Starting task '#{@name}' on #{@hosts.size} host(s)")
+    end
+
+    def execute_commands
+      @options[:parallel] ? execute_parallel : execute_sequential
+    end
+
+    def execute_parallel
+      max_concurrent = determine_max_concurrent
+      pool = create_thread_pool(max_concurrent)
+      futures = create_futures(pool)
+      results = collect_future_results(futures)
+
+      shutdown_pool(pool)
+      results
+    end
+
+    def determine_max_concurrent
+      @options[:max_concurrent] ||
+        Kdeploy.configuration&.max_concurrent_tasks ||
+        10
+    end
+
+    def create_thread_pool(max_concurrent)
+      Concurrent::ThreadPoolExecutor.new(
+        min_threads: 1,
+        max_threads: [max_concurrent, @hosts.size].min
+      )
+    end
+
+    def create_futures(pool)
+      @hosts.map do |host|
+        Concurrent::Future.execute(executor: pool) do
+          execute_on_host(host)
+        end
+      end
+    end
+
+    def collect_future_results(futures)
+      results = {}
+      futures.each_with_index do |future, index|
+        host = @hosts[index]
+        results[host.hostname] = future.value
+      end
+      results
+    end
+
+    def shutdown_pool(pool)
+      pool.shutdown
+      pool.wait_for_termination(30)
+    end
+
+    def execute_sequential
+      results = {}
+
+      @hosts.each do |host|
+        results[host.hostname] = execute_on_host(host)
+
+        if should_stop_execution?(results[host.hostname])
+          log_fail_fast_stop(host)
+          break
+        end
+      end
+
+      results
+    end
+
+    def should_stop_execution?(result)
+      @options[:fail_fast] && !result[:success]
+    end
+
+    def log_fail_fast_stop(host)
+      KdeployLogger.error(
+        "Task '#{@name}' failed on #{host}, stopping execution due to fail_fast option"
+      )
+    end
+
+    def execute_on_host(host)
+      connection = SSHConnection.new(host)
+      host_results = initialize_host_results
+
+      begin
+        connection.connect
+        execute_commands_on_host(host, connection, host_results)
+      rescue StandardError => e
+        handle_host_execution_error(host, e, host_results)
+      ensure
+        connection.cleanup
+      end
+
+      host_results
+    end
+
+    def initialize_host_results
+      {
+        success: true,
+        commands: {},
+        error: nil
+      }
+    end
+
+    def execute_commands_on_host(host, connection, host_results)
+      @commands.each do |command|
+        next unless command.should_run_on?(host)
+
+        command_success = command.execute(host, connection)
+        record_command_result(command, command_success, host_results)
+
+        break if should_stop_command_execution?(command_success, host_results)
+      end
+    end
+
+    def record_command_result(command, success, host_results)
+      host_results[:commands][command.name] = {
+        success: success,
+        result: command.result
+      }
+
+      return if success
+
+      host_results[:success] = false
+      host_results[:error] = "Command '#{command.name}' failed" if @options[:fail_fast]
+    end
+
+    def should_stop_command_execution?(command_success, host_results)
+      !command_success && @options[:fail_fast] && host_results[:error]
+    end
+
+    def handle_host_execution_error(host, error, host_results)
+      KdeployLogger.error("Task '#{@name}' failed on #{host}: #{error.message}")
+      host_results[:success] = false
+      host_results[:error] = error.message
+    end
+
+    def count_successful_hosts(results)
+      results.values.count { |r| r[:success] }
+    end
+
+    def log_task_completion(duration, success_count)
+      KdeployLogger.info(
+        "Task '#{@name}' completed in #{duration.round(2)}s: " \
+        "#{success_count}/#{@hosts.size} hosts successful"
+      )
+    end
+
+    def build_task_result(results, duration, success_count)
+      task_result = {
+        success: calculate_overall_success(results, success_count),
+        results: results,
+        duration: duration,
+        hosts_count: @hosts.size,
+        success_count: success_count
+      }
+
+      record_task_statistics(task_result)
+      task_result
+    end
+
+    def calculate_overall_success(results, success_count)
+      @options[:fail_fast] ? results.values.all? { |r| r[:success] } : success_count.positive?
+    end
+
+    def record_task_statistics(task_result)
+      Kdeploy.statistics.record_task(@name, task_result)
+    end
+  end
+end