kdeploy 0.2.0 → 0.3.0

data/lib/kdeploy/statistics.rb

@@ -1,439 +0,0 @@
-# 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

@@ -1,240 +0,0 @@
-# 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