cem_acpt 0.8.8 → 0.9.1

data/lib/cem_acpt/bolt/cmd/output.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module CemAcpt
+  module Bolt
+    module Cmd
+      # Wraps the output of a Bolt command
+      class Output
+        attr_reader :cmd_output, :items, :target_count, :elapsed_time, :error_obj
+
+        def initialize(cmd_output, strict: true, **item_defaults)
+          @original_cmd_output = cmd_output
+          @strict = strict
+          @item_defaults = item_defaults.transform_keys(&:to_s)
+          init_cmd_output_and_error_obj(cmd_output)
+          @target_count = @cmd_output['target_count'] || 0
+          @elapsed_time = @cmd_output['elapsed_time'] || 0
+        end
+
+        def action
+          items&.map(&:action)&.uniq || [@item_defaults['action']] || ['unknown']
+        end
+
+        def error
+          return nil unless error?
+
+          items.find(&:error?)&.error || error_obj
+        end
+
+        def error?
+          !error_obj.nil? || items.any?(&:error?)
+        end
+
+        def success?
+          !error?
+        end
+
+        def status
+          return 0 if success?
+
+          1
+        end
+
+        def summary
+          @summary ||= [
+            "status: #{success? ? 'passed' : 'failed'}",
+            "items total: #{items.length}",
+            "items succeeded: #{items.count(&:success?)}",
+            "items failed: #{items.count(&:error?)}",
+            "target count: #{target_count}",
+            "elapsed time: #{elapsed_time}",
+          ].join(', ')
+        end
+
+        def summary?
+          true
+        end
+
+        def inspect
+          "#<#{self.class}:#{object_id} #{self}>"
+        end
+
+        def to_h
+          @cmd_output
+        end
+
+        def results
+          @results ||= new_results
+        end
+
+        def results?
+          !results.empty?
+        end
+
+        def to_s
+          return error.to_s if error?
+
+          JSON.pretty_generate(@cmd_output)
+        end
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless to_h == other.to_h
+
+          items.zip(other.items).all? { |a, b| a == b }
+        end
+        alias eql? ==
+
+        # Exists solely for Bolt tests
+        def copy_with_new_items(new_items = [])
+          new_self = self.class.new(original_cmd_output, strict: @strict, **@item_defaults)
+          new_self.items = new_items
+          new_self
+        end
+
+        def method_missing(method, *args, **kwargs, &block)
+          if @cmd_output.respond_to?(method)
+            @cmd_output.send(method, *args, **kwargs, &block)
+          elsif error.respond_to?(method)
+            error.send(method, *args, **kwargs, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          @cmd_output.respond_to?(method, include_private) || error.respond_to?(method, include_private) || super
+        end
+
+        protected
+
+        attr_reader :original_cmd_output
+        attr_writer :cmd_output, :items, :target_count, :elapsed_time, :error_obj
+
+        private
+
+        def init_cmd_output_and_error_obj(cmd_out)
+          case cmd_out
+          when String
+            init_cmd_output_and_error_obj_from_str(cmd_out)
+          when StandardError
+            @error_obj = cmd_out
+            @cmd_output = ruby_error_to_cmd_output_hash(cmd_out)
+          else
+            raise ArgumentError, "cmd_out must be a String or StandardError, got #{cmd_out.class}"
+          end
+        ensure
+          @items = (@cmd_output['items'] || []).map { |item| OutputItem.new(item) }
+          if @items.empty? && @error_obj.nil? && @strict
+            err = RuntimeError.new("Cannot set results, no error or items found for cmd_output:\n#{cmd_output}")
+            @error_obj = err
+            @items = ruby_error_to_cmd_output_hash(err)['items'].map { |item| OutputItem.new(item) }
+          end
+        end
+
+        def init_cmd_output_and_error_obj_from_str(cmd_out)
+          @cmd_output = JSON.parse(cmd_out)
+          if @cmd_output.key?('_error') || @cmd_output.key?('error')
+            err_hash = (@cmd_output['_error'] || @cmd_output['error'])
+            @cmd_output['items'] ||= []
+            @cmd_output['items'] << {
+              'value' => {
+                '_error' => err_hash,
+              },
+            }
+          end
+        rescue JSON::ParserError => e
+          @error_obj = e
+          @cmd_output = ruby_error_to_cmd_output_hash(e)
+        end
+
+        def new_results
+          return new_error_results if items.empty?
+
+          items
+        end
+
+        def new_error_results
+          [error]
+        end
+
+        def ruby_error_to_cmd_output_hash(error)
+          error_kind = [
+            'cem_acpt',
+            error.class.name.split('::').join('.'),
+          ].join('.')
+          details = { 'exit_code' => 1 }
+          details['backtrace'] = error.backtrace if error.backtrace
+          {
+            'items' => [
+              {
+                'value' => {
+                  '_error' => {
+                    'kind' => error_kind,
+                    'msg' => error.to_s,
+                    'issue_code' => 'CEM_ACPT_ERROR',
+                    'details' => {
+                      'exit_code' => 1,
+                      'backtrace' => error.backtrace,
+                    },
+                  },
+                },
+              },
+            ],
+          }
+        end
+      end
+
+      # Represents a single item in the output of a Bolt command
+      class OutputItem
+        ATTR_DEFVAL = 'unknown'
+
+        attr_reader :target, :action, :object, :status, :value
+
+        def initialize(item_hash, **item_defaults)
+          @item_hash = item_hash
+          @item_defaults = item_defaults.transform_keys(&:to_s)
+          @target = item_hash['target'] || @item_defaults['target'] || ATTR_DEFVAL
+          @action = item_hash['action'] || @item_defaults['action'] || ATTR_DEFVAL
+          @object = item_hash['object'] || @item_defaults['object'] || ATTR_DEFVAL
+          @status = item_hash['status'] || 'failure'
+          @value = item_hash['value'] || {}
+        end
+
+        def error?
+          !success?
+        end
+
+        def error
+          return unless error?
+
+          @error ||= new_error
+        end
+
+        def success?
+          status == 'success'
+        end
+
+        def output
+          return nil if error?
+
+          value['_output'] || value['output'] || value
+        end
+
+        def to_h
+          @item_hash
+        end
+
+        def to_s
+          "#<#{self.class}:#{object_id.to_s(16)} #{target},#{action},#{object},#{status}>"
+        end
+
+        def inspect
+          to_s
+        end
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          to_h == other.to_h
+        end
+        alias eql? ==
+
+        private
+
+        def new_error
+          if value.is_a?(Hash) && (value.key?('_error') || value.key?('error'))
+            OutputError.new(value['_error'] || value['error'])
+          else
+            OutputError.new(
+              {
+                'kind' => 'cem_acpt.unknown',
+                'msg' => value,
+                'details' => { 'exit_code' => 1 },
+              },
+            )
+          end
+        end
+      end
+
+      # Represents a Bolt error value
+      class OutputError
+        attr_accessor :kind, :issue_code, :msg, :details
+
+        def initialize(error_hash)
+          @error_hash = error_hash
+          @kind = error_hash['kind']
+          @issue_code = error_hash['issue_code'] || 'OTHER_ERROR'
+          @msg = error_hash['msg']
+          @details = error_hash['details']
+        end
+
+        def error?
+          true
+        end
+
+        def success?
+          false
+        end
+
+        def status
+          'failure'
+        end
+
+        def exit_code
+          details['exit_code'] || 1
+        end
+
+        def backtrace
+          details['backtrace'] || []
+        end
+
+        def to_s
+          "issue code: #{issue_code}, kind: #{kind}, message: #{msg}"
+        end
+
+        def inspect
+          "#<#{self.class.name}(#{self.class.object_id})#{self}>"
+        end
+
+        def to_h
+          @error_hash
+        end
+
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          to_h == other.to_h
+        end
+        alias eql? ==
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/cmd/task.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module CemAcpt
+  module Bolt
+    module Cmd
+      # Base class for task commands
+      class TaskBase < Base
+        attr_accessor :task_name
+        attr_reader :sub_command, :item_defaults
+        option :module_path, '--modulepath', config_path: 'bolt.module_path', default: Dir.pwd
+        option :log_level, '--log-level', config_path: 'bolt.log_level', default: 'warn'
+        option :clear_cache, '--clear-cache', config_path: 'bolt.clear_cache', default: false, bool_flag: true
+        option :project, '--project', config_path: 'bolt.project.path'
+
+        def initialize(config, sub_command = nil, task_name = nil)
+          @config = config
+          @sub_command = sub_command
+          @task_name = task_name
+          @item_defaults = {
+            'action' => 'task',
+            'object' => @task_name,
+          }
+          super()
+        end
+
+        def command_family
+          'task'
+        end
+
+        def cmd
+          join_array([bolt_bin, 'task', sub_command, task_name, options])
+        end
+      end
+
+      # Runs the Bolt task show command
+      class TaskShow < TaskBase
+        def initialize(config, task_name = nil, project: nil)
+          super(config, 'show', task_name)
+          @project = project.is_a?(String) ? project : project&.path
+        end
+      end
+
+      # Runs the Bolt task run command
+      class TaskRun < TaskBase
+        option :inventory, '--inventoryfile', config_path: 'bolt.inventory_path'
+        option :targets, '--targets', config_path: 'bolt.targets', default: 'nix'
+        supports_params
+
+        def initialize(config, task_name = nil, inventory: nil, project: nil)
+          super(config, 'run', task_name)
+          @inventory = inventory.is_a?(String) ? inventory : inventory&.path
+          @project = project.is_a?(String) ? project : project&.path
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/cmd.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'cmd/task'
+
+module CemAcpt
+  module Bolt
+    # Namespace for all Bolt command classes
+    module Cmd
+      # Represents the output of a Bolt command
+      # @param cmd_output [String, StandardError] the output of a Bolt command or an error
+      # @param strict [Boolean] whether to raise an error if the output does not match the expected format
+      # @param item_defaults [Hash] default values for the item.
+      # @option item_defaults [String] :action The action that was performed (ex: 'task')
+      # @option item_defaults [String] :object The object that the action was performed on (ex. The Bolt task name)
+      # @options item_defaults [String] :target The IP address of the target that the action was performed on
+      # @return [Output] a new Output object for the given command output
+      def self.new_output(cmd_output, strict: true, **item_defaults)
+        Output.new(cmd_output, strict: strict, **item_defaults)
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/errors.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  module Bolt
+    # Class for general Bolt errors. Can also wrap other errors.
+    class BoltActionError < StandardError
+      attr_reader :original_error, :bolt_action, :bolt_object
+
+      def initialize(msg = 'Bolt error occured', original_error = nil, bolt_action = nil, bolt_object = nil)
+        @original_error = original_error
+        @bolt_action = bolt_action
+        @bolt_object = bolt_object
+        unless @original_error.nil?
+          set_backtrace(@original_error.backtrace)
+          msg = "#{msg}: #{@original_error}"
+        end
+        super(msg)
+      end
+
+      def bolt_target
+        @bolt_target ||= @bolt_object&.target
+      end
+
+      def to_h
+        {
+          bolt_action: bolt_action,
+          bolt_object: bolt_object,
+          original_error: original_error,
+          message: message,
+          backtrace: backtrace,
+        }
+      end
+    end
+
+    # Class for Bolt project errors. Can also wrap other errors.
+    class BoltProjectError < BoltActionError
+      def initialize(msg = 'Bolt project error occured', original_error = nil, *_args)
+        super(msg, original_error, 'project', 'bolt-project.yaml')
+      end
+    end
+
+    # Class for Bolt inventory errors. Can also wrap other errors.
+    class BoltInventoryError < BoltActionError
+      def initialize(msg = 'Bolt inventory error occured', original_error = nil, *_args)
+        super(msg, original_error, 'inventory', 'inventory.yaml')
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/helpers.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative '../utils/shell'
+
+module CemAcpt
+  module Bolt
+    # Module containing helper methods for Bolt
+    module Helpers
+      BOLT_PROJECT_FILE = 'bolt-project.yaml'
+      INVENTORY_FILE = 'inventory.yaml'
+
+      def load_object_test(bolt_test_data, bolt_object)
+        return { params: {} } unless bolt_test_data
+
+        bolt_test_data[bolt_object].transform || { params: {} }
+      end
+
+      def new_bolt_project_hash(module_name, config)
+        {
+          'name' => module_name,
+          'analytics' => false,
+        }.merge(config.get('bolt.project')&.transform_keys(&:to_s) || {})
+      end
+
+      def new_inventory_hash(hosts, private_key, config)
+        {
+          'groups' => [
+            {
+              'name' => 'nix',
+              'targets' => hosts,
+              'config' => {
+                'transport' => 'ssh',
+                'ssh' => {
+                  'connect-timeout' => 60,
+                  'disconnect-timeout' => 60,
+                  'host-key-check' => false,
+                  'private-key' => private_key || '~/.ssh/id_rsa',
+                  'run-as' => 'root',
+                  'tmpdir' => '/var/tmp', # /tmp is usually noexec
+                }.merge(config.get('bolt.transport.ssh')&.transform_keys(&:to_s) || {}),
+              },
+            },
+          ],
+        }
+      end
+
+      def bolt_bin
+        @bolt_bin ||= CemAcpt::Utils::Shell.which('bolt', raise_if_not_found: true)
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/inventory.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+require_relative 'yaml_file'
+
+module CemAcpt
+  module Bolt
+    # Provides an abstraction for the Bolt inventory file
+    class Inventory < YamlFile
+      attr_reader :config, :hosts, :private_key
+
+      def initialize(config, hosts = [], private_key = nil)
+        path = config.get('bolt.inventory_path') || 'inventory.yaml'
+        super(path)
+        @config = config
+        @hosts = hosts
+        @private_key = private_key
+        @hash = new_inventory_hash(hosts, private_key, config)
+      end
+
+      def hosts=(hosts)
+        return if @hosts == hosts
+
+        @hosts = hosts
+        @hash = new_inventory_hash(hosts, @private_key, @config)
+      end
+
+      def private_key=(private_key)
+        return if @private_key == private_key
+
+        @private_key = private_key
+        @hash = new_inventory_hash(@hosts, private_key, @config)
+      end
+
+      private
+
+      def new_inventory_hash(hosts, private_key, config)
+        {
+          'groups' => [
+            {
+              'name' => 'nix',
+              'targets' => hosts,
+              'config' => {
+                'transport' => 'ssh',
+                'ssh' => {
+                  'connect-timeout' => 60,
+                  'disconnect-timeout' => 60,
+                  'host-key-check' => false,
+                  'private-key' => private_key || '~/.ssh/id_rsa',
+                  'run-as' => 'root',
+                  'tmpdir' => '/var/tmp', # /tmp is usually noexec
+                }.merge(config.get('bolt.transport.ssh')&.transform_keys(&:to_s) || {}),
+              },
+            },
+          ],
+        }
+      rescue StandardError => e
+        raise CemAcpt::Bolt::InventoryError.new('Error creating Bolt inventory hash', e)
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/project.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+require_relative 'yaml_file'
+
+module CemAcpt
+  module Bolt
+    # Provides an abstraction for the Bolt project file / config
+    class Project < YamlFile
+      attr_reader :config, :module_name
+
+      def initialize(config, module_name)
+        path = config.get('bolt.project.path') || 'bolt-project.yaml'
+        super(path)
+        @config = config
+        @module_name = module_name
+        @hash = new_bolt_project_hash(module_name, config)
+      end
+
+      def latest_saved?
+        # We consider the project file to be up to date if it is subset of the contents on disk
+        # or equal to the contents on disk
+        (@hash == @saved_hash) || lte_to_disk?
+      end
+
+      private
+
+      def new_bolt_project_hash(module_name, config)
+        {
+          'name' => module_name,
+          'analytics' => false,
+        }.merge(config.get('bolt.project')&.transform_keys(&:to_s) || {})
+      rescue StandardError => e
+        raise CemAcpt::Bolt::BoltProjectError.new('Error creating Bolt project hash', e)
+      end
+    end
+  end
+end

data/lib/cem_acpt/bolt/summary_results.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../utils/finalizer_queue'
+
+module CemAcpt
+  module Bolt
+    # Class that holds the results of the entire Bolt test suite.
+    class SummaryResults < CemAcpt::Utils::FinalizerQueue
+      alias all to_a
+
+      def error
+        require_finalized(binding)
+        return unless error?
+
+        @error ||= find { |r| !r.success? }
+      end
+
+      def error?
+        require_finalized(binding)
+        !success?
+      end
+
+      def success?
+        require_finalized(binding)
+        @success ||= all?(&:success?)
+      end
+
+      def success_count
+        require_finalized(binding)
+        @success_count ||= count(&:success?)
+      end
+
+      def failure_count
+        require_finalized(binding)
+        @failure_count ||= length - success_count
+      end
+
+      def status
+        require_finalized(binding)
+        success? ? 0 : 1
+      end
+
+      def status_str
+        require_finalized(binding)
+        success? ? 'passed' : 'failed'
+      end
+
+      def summary
+        require_finalized(binding)
+        @summary ||= [
+          "status: #{status_str}",
+          "tests total: #{length}",
+          "tests succeeded: #{success_count}",
+          "tests failed: #{failure_count}",
+        ].join(', ')
+      end
+
+      def summary?
+        require_finalized(binding)
+        true
+      end
+
+      def inspect
+        return "#<#{self.class}:#{object_id} unfinalized>" unless finalized?
+
+        "#<#{self.class}:#{object_id} #{self}>"
+      end
+
+      def to_h
+        require_finalized(binding)
+        { 'summary' => summary, 'status' => status, 'results' => map(&:to_h) }
+      end
+
+      def action
+        require_finalized(binding)
+        map { |rs| rs.results.map(&:action).uniq }.flatten.uniq
+      end
+
+      def results
+        require_finalized(binding)
+        @results ||= map(&:results).flatten
+      end
+
+      def results?
+        require_finalized(binding)
+        !results.empty?
+      end
+
+      def to_s
+        require_finalized(binding)
+        JSON.pretty_generate(to_h)
+      end
+    end
+  end
+end