cem_acpt 0.8.7 → 0.9.0

data/lib/cem_acpt/bolt.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'yaml'
+require_relative 'logging'
+require_relative 'bolt/cmd'
+require_relative 'bolt/helpers'
+require_relative 'bolt/inventory'
+require_relative 'bolt/project'
+require_relative 'bolt/summary_results'
+require_relative 'bolt/tasks'
+require_relative 'bolt/tests'
+require_relative 'utils/files'
+require_relative 'utils/puppet'
+require_relative 'utils/shell'
+
+module CemAcpt
+  # Holds all the Bolt related code
+  module Bolt
+    # Class for running Bolt tests
+    class TestRunner
+      include CemAcpt::Logging
+      include CemAcpt::Bolt::Helpers
+
+      attr_reader :hosts, :results, :run_data
+
+      def initialize(config, run_data: {}, hosts: [])
+        @config = config
+        @run_data = run_data
+        @tests = nil
+        @hosts = hosts
+        @module_name = File.basename(Dir.pwd).gsub(%r{puppetlabs-}, '')
+        @bolt_project_setup = false
+        @inventory = CemAcpt::Bolt::Inventory.new(config, hosts, run_data[:private_key])
+        @project = CemAcpt::Bolt::Project.new(config, @module_name)
+        @results = CemAcpt::Bolt::SummaryResults.new
+      end
+
+      def tests
+        @tests ||= CemAcpt::Bolt::Tests::TestList.new(@config, @run_data, @inventory, @project)
+      end
+
+      def setup!
+        return if setup?
+
+        @project.save! unless @project.latest_saved?
+        @inventory.save! unless @inventory.latest_saved?
+        tests.setup! unless tests.setup?
+      end
+
+      def setup?
+        @project.latest_saved? && @inventory.latest_saved? && tests.setup?
+      end
+
+      def teardown!
+        logger.debug('CemAcpt::Bolt') { 'Tearing down Bolt project...' }
+        @inventory.delete!
+        @project.delete!
+      end
+
+      def hosts=(hosts)
+        @hosts = hosts
+        @inventory.hosts = hosts
+      end
+
+      def run_data=(run_data)
+        @run_data = run_data
+        @inventory.private_key = run_data[:private_key]
+      end
+
+      def run(threaded: true)
+        raise BoltActionError, 'Cannot run Bolt tests, no hosts specified' if hosts.nil? || hosts.empty?
+
+        logger.info('CemAcpt::Bolt') { "Preparing to run Bolt tests for module #{@module_name}..." }
+        if threaded
+          run_in_context { |t| run_threaded(t) }
+        else
+          run_in_context { |t| run_synchronous(t) }
+        end
+      rescue StandardError => e
+        errmsg = "Error running Bolt tests for module #{@module_name}"
+        wrapped_error = CemAcpt::Bolt::BoltActionError.new(errmsg, e, "#{self.class.name}#run")
+        logger.error('CemAcpt::Bolt') { errmsg }
+        logger.debug('CemAcpt::Bolt') { "Backtrace:\n#{e.backtrace.join("\n")}" }
+        @results << CemAcpt::Bolt::Tests::TestResult.new(
+          'Bolt test runner error',
+          nil,
+          nil,
+          error: wrapped_error,
+        )
+      ensure
+        @results.finalize!
+        @results
+      end
+
+      private
+
+      def max_threads
+        @max_threads ||= @config.get('bolt.max_threads') || 5
+      end
+
+      def run_in_context
+        raise 'No block given' unless block_given?
+
+        setup! unless setup?
+        yield @tests
+      ensure
+        teardown! if setup?
+      end
+
+      def run_threaded(tests_to_run = @tests)
+        test_groups = tests_to_run.split_into_groups(max_threads)
+        logger.info('CemAcpt::Bolt') do
+          "Running #{tests_to_run.length} Bolt test(s) in #{test_groups.length} group(s) against #{hosts.length} host(s)..."
+        end
+        threads = []
+        test_groups.each do |test_group|
+          threads << Thread.new do
+            test_group.each do |t|
+              t.run
+              result = t.result
+              logger.debug('CemAcpt::Bolt') { "Bolt test result:\n#{result}" }
+              @results << result
+            end
+          end
+        end
+        threads.each(&:join)
+      end
+
+      def run_synchronous(tests_to_run = @tests)
+        logger.info('CemAcpt::Bolt') do
+          "Running #{tests_to_run.length} Bolt test(s) against #{hosts.length} host(s)..."
+        end
+        tests_to_run.to_a.each do |t|
+          t.run
+          @results << t.result
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/cli.rb

@@ -35,6 +35,12 @@ module CemAcpt
           opts.on('-t', '--tests TESTS', 'Set tests. Example: -t "test1,test2"') do |t|
             options[:tests] = t.split(',')
           end
+
+          opts.on('-B', '--no-bolt-tests', 'Do not run Bolt tests') do
+            options[:bolt] ||= {}
+            options[:bolt][:tests] ||= {}
+            options[:bolt][:tests][:enabled] = false
+          end
         when :cem_acpt_image
           opts.on('--dry-run', 'Logs the information for the images that would be created. Does not create images.') do
             options[:dry_run] = true

data/lib/cem_acpt/config/base.rb

@@ -47,6 +47,10 @@ module CemAcpt
         load(opts: opts, config_file: config_file)
       end
 
+      def inspect
+        "#<#{self.class}:#{object_id.to_s(16)}>"
+      end
+
       # @return [String] The prefix for environment variables
       def env_var_prefix
         'CEM_ACPT'

data/lib/cem_acpt/config/cem_acpt.rb

@@ -8,6 +8,7 @@ module CemAcpt
     class CemAcpt < Base
       VALID_KEYS = %i[
         actions
+        bolt
         image_name_builder
         module_dir
         node_data
@@ -19,6 +20,11 @@ module CemAcpt
       def defaults
         {
           actions: {},
+          bolt: {
+            tests: {
+              enabled: true,
+            },
+          },
           ci_mode: false,
           config_file: nil,
           image_name_builder: {
@@ -38,7 +44,7 @@ module CemAcpt
           quiet: false,
           test_data: {
             for_each: {
-              collection: %w[puppet7],
+              collection: %w[puppet7 puppet8],
             },
             vars: {},
             name_pattern_vars: %r{^(?<framework>[a-z]+)_(?<image_fam>[a-z0-9-]+)_(?<firewall>[a-z]+)_(?<framework_vars>[-_a-z0-9]+)$},

data/lib/cem_acpt/core_ext.rb

@@ -63,4 +63,29 @@ module CemAcpt::CoreExt
       alias dset dot_store
     end
   end
+
+  # Refines the Array class with some convenience methods.
+  module ExtendedArray
+    refine Array do
+      # Splits the array into the given number of groups.
+      # If the array cannot be evenly split, the last group(s)
+      # will contain the remainder.
+      # Example:
+      #   [1, 2, 3, 4, 5].split_into_groups(2) #=> [[1, 2, 3], [4, 5]]
+      #   [1, 2, 3, 4, 5].split_into_groups(3) #=> [[1, 2, 3], [4], [5]]
+      def split_into_groups(num_groups)
+        group_size = size / num_groups
+        leftovers = size % num_groups
+
+        groups = []
+        start = 0
+        num_groups.times do |i|
+          length = group_size + ((leftovers > 0 && leftovers > i) ? 1 : 0)
+          groups << slice(start, length)
+          start += length
+        end
+        groups
+      end
+    end
+  end
 end

data/lib/cem_acpt/goss/api/action_response.rb

@@ -39,6 +39,10 @@ module CemAcpt
           status == 200
         end
 
+        def error?
+          !success?
+        end
+
         def results
           @results ||= @body['results'].map { |r| ActionResponseResult.new(r) }
         end

data/lib/cem_acpt/goss/api.rb

@@ -11,17 +11,17 @@ module CemAcpt
   module Goss
     # Holds methods for interacting with the Goss API running on a test node.
     module Api
+      # The actions that can be run against the Goss API. The key is the action
+      # name and the value is the port/endpoint of the action.
+      ACTIONS = {
+        acpt: '8080/acpt',
+        idempotent: '8081/idempotent',
+        noop: '8082/noop',
+      }.freeze
+
       class << self
         include CemAcpt::Logging
 
-        # The actions that can be run against the Goss API. The key is the action
-        # name and the value is the port/endpoint of the action.
-        ACTIONS = {
-          acpt: '8080/acpt',
-          idempotent: '8081/idempotent',
-          noop: '8082/noop',
-        }.freeze
-
         # Create a URI for the specified action against the specified host.
         # @param host [String] The host to run the action against. This should be
         #   a public IP address or a DNS-resolvable name.
@@ -32,31 +32,30 @@ module CemAcpt
         end
 
         # Run the specified actions against the specified hosts asynchronously.
-        # @param hosts [Array<String>] The hosts to run the actions against. Each
+        # @param context [Hash] The context for the test run.
+        # @option context [Array<String>] :hosts The hosts to run the actions against. Each
         #   host should be a public IP address or a DNS-resolvable name.
-        # @param results [Queue] The queue to push the results to.
-        # @param only [Array<Symbol>] The actions to run.
-        # @param except [Array<Symbol>] The actions to skip.
+        # @option context [Queue] :results The queue to push the results to.
+        # @option [Array<String>] :actions The actions to run.
         # @return [Queue] The queue of results.
-        def run_actions_async(hosts, results: Queue.new, only: [], except: [])
+        def run_actions_async(context = {})
+          actions = context[:actions] || []
+          hosts = context[:hosts] || []
+          results = context[:results] || Queue.new
           raise ArgumentError, 'hosts must be an Array' unless hosts.is_a?(Array)
           raise ArgumentError, 'results must be a Queue-like object implementing #<<' unless results.respond_to?(:<<)
-          raise ArgumentError, 'only must be an Array' unless except.is_a?(Array)
-          raise ArgumentError, 'except must be an Array' unless except.is_a?(Array)
-          logger.info('CemAcpt::Goss::Api') { "Running test actions against #{hosts.size} host(s)..." }
-          only.map!(&:to_sym)
-          except.map!(&:to_sym)
-          only_specified = !only.empty?
-          except_specified = !except.empty?
+          raise ArgumentError, 'actions must be an Array' unless actions.is_a?(Array)
+
+          actions.map!(&:to_sym)
+          logger.info('CemAcpt::Goss::Api') do
+            "Running test actions #{actions.join(', ')} against #{hosts.size} host(s)..."
+          end
           task = Async do
             internet = Async::HTTP::Internet.new
             barrier = Async::Barrier.new
             barrier.async do
               hosts.each do |host|
-                ACTIONS.each_key do |action|
-                  next if only_specified && !only.include?(action)
-                  next if except_specified && except.include?(action)
-
+                actions.each do |action|
                   results << run_action(internet, host, action)
                 end
               end
@@ -64,7 +63,6 @@ module CemAcpt
             barrier.wait
           ensure
             internet&.close
-            results.close if results.respond_to?(:close)
           end
           task.wait
           logger.info('CemAcpt::Goss::Api') { 'Finished running test actions, returning results...' }

data/lib/cem_acpt/logging/formatter.rb

@@ -18,7 +18,7 @@ module CemAcpt
         def all
           @all ||= [FileFormatter.new, JSONFormatter.new, TextFormatter.new, GithubActionFormatter.new]
         end
-      end      
+      end
 
       class FileFormatter
         attr_reader :log_format
@@ -26,10 +26,10 @@ module CemAcpt
         def initialize
           @log_format = :file
         end
-  
+
         def get
           proc do |severity, datetime, progname, msg|
-            format(severity, datetime, progname, msg)
+            self.format(severity, datetime, progname, msg)
           end
         end
 

data/lib/cem_acpt/logging.rb

@@ -73,7 +73,7 @@ module CemAcpt
 
       def initialize(logdev, shift_age = 0, shift_size = 1_048_576, **kwargs)
         @config_hash = { logdev: logdev, shift_age: shift_age, shift_size: shift_size, **kwargs }
-        @ci_mode = (kwargs[:formatter].downcase.to_sym == :github_action || !ENV['GITHUB_ACTIONS'].nil? || !ENV['CI'].nil?)
+        @ci_mode = (kwargs[:formatter]&.downcase&.to_sym == :github_action || !ENV['GITHUB_ACTIONS'].nil? || !ENV['CI'].nil?)
         kwargs[:formatter] = CemAcpt::Logging::Formatter.for(kwargs[:formatter]) if kwargs[:formatter]
         super(logdev, shift_age, shift_size, **kwargs)
         @raw_logdev = logdev # Used for logging from trap context
@@ -93,6 +93,10 @@ module CemAcpt
         debug(progname, &block)
       end
 
+      def verbose?
+        @verbose
+      end
+
       def debug(progname = nil, &block)
         severity = 'debug'
         return log_trap_context(severity, progname, &block) if log_trap_context?(severity)
@@ -243,6 +247,10 @@ module CemAcpt
         @logger.level = LEVEL_MAP[level.downcase]
       end
 
+      def verbose?
+        logger.is_a?(CemAcpt::Logging::MultiLogger) ? logger.verbose?.all? : logger.verbose?
+      end
+
       # Shows the current log format style if set, or the default if not.
       # @return [Symbol] the current log format style
       def current_log_format
@@ -332,6 +340,10 @@ module CemAcpt
           CemAcpt::Logging.new_log_level(level)
         end
 
+        def verbose?
+          CemAcpt::Logging.verbose?
+        end
+
         def current_log_format
           CemAcpt::Logging.current_log_format
         end
@@ -369,6 +381,10 @@ module CemAcpt
       CemAcpt::Logging.new_log_level(level)
     end
 
+    def verbose?
+      CemAcpt::Logging.verbose?
+    end
+
     def current_log_format
       CemAcpt::Logging.current_log_format
     end

data/lib/cem_acpt/provision/terraform/linux.rb

@@ -11,7 +11,7 @@ module CemAcpt
       end
 
       def self.valid_versions
-        %w[7 8]
+        %w[7 8 9]
       end
 
       def systemd_files

data/lib/cem_acpt/test_data.rb

@@ -45,6 +45,7 @@ module CemAcpt
           raise "Goss file not found for test #{test_name}" unless File.exist?(goss_file)
           raise "Puppet manifest not found for test #{test_name}" unless File.exist?(puppet_manifest)
 
+          bolt_test = File.expand_path(File.join(test_dir, 'bolt.yaml'))
           logger.debug('CemAcpt::TestData') { "Complete test directory found for test #{test_name}: #{test_dir}" }
           test_data = {
             test_name: test_name,
@@ -52,6 +53,7 @@ module CemAcpt
             goss_file: goss_file,
             puppet_manifest: puppet_manifest,
           }
+          test_data[:bolt_test] = bolt_test if File.exist?(bolt_test)
 
           process_for_each(test_data).each do |test_data_i|
             process_static_vars(test_data_i)

data/lib/cem_acpt/test_runner/log_formatter/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      # Base class for log formatters
+      class Base
+        INDENT = '  '
+
+        attr_accessor :subject
+
+        def initialize(subject = nil)
+          @subject = subject
+        end
+
+        def inspect
+          to_s
+        end
+
+        def to_s
+          "#<#{self.class.name}:0x#{object_id.to_s(16)}>"
+        end
+
+        def summary(response = nil)
+          register_response(response)
+        end
+
+        def results(response = nil)
+          register_response(response)
+        end
+
+        def host_name(response = nil)
+          register_response(response)
+        end
+
+        def test_name(response = nil)
+          register_response(response)
+        end
+
+        private
+
+        def register_response(response = nil)
+          raise ArgumentError, 'either subject or response must be provided' if @subject.nil? && response.nil?
+
+          @response = response
+        end
+
+        def log_subject
+          @response || @subject
+        end
+
+        def normalize_whitespace(str)
+          raise ArgumentError, 'str must be a String' unless str.is_a?(String)
+
+          str.gsub(%r{(\n|\r|\t)}, ' ').gsub(%r{\s{2,}}, ' ').strip
+        end
+
+        def success_str(success)
+          success ? 'passed' : 'failed'
+        end
+
+        def name_from_ip(ip)
+          raise 'class does not provide instance_names_ips instance variable' if @instance_names_ips.nil?
+
+          @instance_names_ips.each do |name, val|
+            return name if val['ip'] == ip
+          end
+          ip
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/test_runner/log_formatter/bolt_error_formatter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      class BoltErrorFormatter < Base
+        def initialize(subject: nil)
+          super(subject)
+        end
+
+        def summary(response = nil)
+          super(response)
+          "Error: #{log_subject.summary}"
+        end
+
+        def results(response = nil)
+          super(response)
+          log_subject.results.map do |res|
+            format_failed_result(res)
+          end
+        end
+
+        def host_name(response = nil)
+          super(response)
+          "Error: #{log_subject.error.class.name}"
+        end
+
+        def test_name(response = nil)
+          super(response)
+          "Error: #{log_subject.error.class.name}"
+        end
+
+        private
+
+        def format_failed_result(res)
+          prefix = [
+            'Failed',
+            "action #{res.action}",
+            "object #{res.object}",
+            "target #{res.target}",
+          ].join(': ')
+          return prefix unless res.error?
+
+          error_parts = [
+            "error type #{res.error.class.name}",
+            normalize_whitespace(res.error.to_s),
+          ]
+          if res.error.respond_to?(:details) && res.error.details
+            error_parts << "details #{res.error.details}"
+          end
+          if res.error.respond_to?(:original_error) && res.error.original_error
+            error_parts << "original error #{res.error.original_error.class.name}"
+            error_parts << "original message #{res.error.original_error.message}"
+          end
+          if res.error.respond_to?(:backtrace) && !res.error.backtrace.empty?
+            error_parts << "backtrace:\n#{res.error.backtrace.join("\n#{INDENT}#{INDENT}")}"
+          end
+          "#{prefix}\n#{INDENT}#{error_parts.join("\n#{INDENT}")}"
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/test_runner/log_formatter/bolt_output_formatter.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      # Formats the results of a Bolt action
+      class BoltOutputFormatter < Base
+        def initialize(config, instance_names_ips, subject: nil)
+          super(subject)
+          @config = config
+          @instance_names_ips = instance_names_ips
+        end
+
+        def summary(response = nil)
+          super(response)
+          [
+            "SUMMARY: #{test_name(log_subject)}:",
+            normalize_whitespace(log_subject.summary),
+          ].join(' ')
+        end
+
+        def results(response = nil)
+          super(response)
+          log_subject.results.map do |res|
+            prefix = success_str(res.success?).capitalize
+            parts = [
+              prefix,
+              "action #{res.action}",
+              "host(s) #{host_name(log_subject)}",
+              "object #{res.object}",
+              "status #{res.status}",
+            ]
+            parts << res.error if res.error?
+            parts.join(': ')
+          end
+        end
+
+        def host_name(response = nil)
+          super(response)
+          log_subject.items.map { |i| name_from_ip(i.target) }.compact.uniq.join(', ')
+        end
+
+        def test_name(response = nil)
+          super(response)
+          test_type = (log_subject.items.find { |i| i.action != 'unknown' }&.action || 'unknown')
+          test_objects = log_subject.items.map(&:object).uniq.join(', ')
+          "Bolt #{test_type} test for: #{test_objects}"
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/test_runner/log_formatter/bolt_summary_results_formatter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+
+module CemAcpt
+  module TestRunner
+    module LogFormatter
+      # Formats the results of a Bolt::SummaryResults object
+      class BoltSummaryResultsFormatter < Base
+        def initialize(config, instance_names_ips, subject: nil)
+          super(subject)
+          @config = config
+          @instance_names_ips = instance_names_ips
+        end
+
+        def summary(response = nil)
+          super(response)
+          [
+            "SUMMARY: #{test_name(log_subject)}:",
+            normalize_whitespace(log_subject.summary),
+          ].join(' ')
+        end
+
+        def results(response = nil)
+          super(response)
+          log_subject.each_with_object([]) do |res, ary|
+            res.results.each do |r|
+              header = [
+                "#{success_str(r.success?).capitalize}: #{r.name}",
+                "action: #{r.action}",
+                "target: #{name_from_ip(r.target)}",
+                "object: #{r.object}",
+                "status: #{r.status}",
+              ]
+              parts = [
+                header.join(', '),
+                "validation results:\n#{JSON.pretty_generate(r.failed_validation_results)}",
+              ]
+              if CemAcpt::Logging.verbose?
+                parts << "command result:\n#{JSON.pretty_generate(r.command_result.to_h)}"
+              end
+              parts << r.error if r.error?
+              if r.respond_to?(:details) && !r.details&.empty?
+                parts << "details:\n#{JSON.pretty_generate(r.details)}\n"
+              end
+              ary << parts.join("\n")
+            end
+          end
+        end
+
+        def host_name(response = nil)
+          super(response)
+          log_subject.items.map { |i| name_from_ip(i.target) }.compact.uniq.join(', ')
+        end
+
+        def test_name(response = nil)
+          super(response)
+          'Bolt tests'
+        end
+      end
+    end
+  end
+end