cem_acpt 0.3.4-universal-java-17 → 0.3.5-universal-java-17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c289fcb52a1115630ffece04c465e5a8d945bdefdcc99fbf73a800398d2f2bc6
-  data.tar.gz: aca0f41efe831bf5bb8dc4399cd1a2d771f7bb72fb1ee13eeccb79d59bd45183
+  metadata.gz: b62e59f800597758c9a69bc1ede3d3f97a9a68c6c38f0d4705201ac2613feab9
+  data.tar.gz: 4d4a0ad559702df7cff661726a962b0bbc278d2cb0ecba48241a67a55345dac6
 SHA512:
-  metadata.gz: 65dd7b8c5023304f0c5f9fd371a64cfb157567004d6f93ebdadc76bbf99f50f7483fab575f73fb9c07256cbb0db688ad4d8c10a6b644a8f7670a3441a54e866e
-  data.tar.gz: 2504bc3dc1ef1ac1a09c16d00c3cd99b08127ccd31f2b9da134f31ffb2dc19730eda580ec893def0a9b183bd4198c5aa8263ea735f50c0b2c21156a5f8f7124d
+  metadata.gz: ee72270cae3121c03597e12f91c3fd6134da4ab40ef342cc3f694ea0a5ee2dcaf37363e9430b2610539120e0cf5ea733caf191d916a926e2d29dc17ac8bc7cfb
+  data.tar.gz: 79a40b4e74935a7842bffd7b9252aa63d277cc31e49c0a3a10200f647117a1c3e51d4183a3e2e16aa9cc0e1fd185d0ee375177fdc876ca4097e8828884b55f36

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cem_acpt (0.3.4-universal-java-17)
+    cem_acpt (0.3.5-universal-java-17)
       concurrent-ruby (>= 1.1, < 2.0)
       deep_merge (>= 1.2, < 2.0)
       ed25519 (>= 1.2, < 2.0)

data/lib/cem_acpt/platform/gcp/cmd.rb

@@ -113,6 +113,9 @@ module CemAcpt::Platform::Gcp
 
     # Deletes a GCP VM instance.
     def delete_instance(instance_name)
+      ssh_all_known_hosts.each do |kh_file|
+        CemAcpt::Platform::Utils::Linux::SSHelper.remove_known_host(vm_alias(instance_name), kh_file)
+      end
       local_exec("compute instances delete #{instance_name} --quiet")
     rescue StandardError
       # Ignore errors when deleting instances.
@@ -318,6 +321,14 @@ module CemAcpt::Platform::Gcp
       "compute.#{vm_describe(vm)['id']}"
     end
 
+    def ssh_all_known_hosts
+      [
+        File.join(ENV['HOME'], '.ssh', 'acpt_test_known_hosts'),
+        File.join(ENV['HOME'], '.ssh', 'known_hosts'),
+        File.join(ENV['HOME'], '.ssh', 'google_compute_known_hosts'),
+      ]
+    end
+
     # Default options for Net::SSH
     def default_ssh_opts
       {

data/lib/cem_acpt/platform/utils/linux.rb

@@ -4,6 +4,43 @@ module CemAcpt
   module Platform
     module Utils
       module Linux
+        # Module provides SSH helper methods for Linux platforms
+        class SSHelper
+          def self.ssh_keygen?
+            system('command -v ssh-keygen 2>&1 > /dev/null')
+          end
+
+          def self.remove_known_host(host, file = File.join([ENV['HOME'], '.ssh', 'known_hosts']))
+            if File.exist?(file)
+              if ssh_keygen?
+                system("ssh-keygen -R #{host} -f #{file} 2>&1 > /dev/null")
+              else
+                remove_known_host_no_keygen(host, file)
+              end
+            end
+          end
+
+          def self.remove_known_host_no_keygen(host, file = File.join([ENV['HOME'], '.ssh', 'known_hosts']))
+            require 'fileutils'
+            found = false
+            File.open("#{file}.cem_acpt_new", 'w') do |f|
+              File.readlines(file).each do |line|
+                if line.include?(host)
+                  found = true
+                else
+                  f.puts(line)
+                end
+              end
+            end
+            if found
+              FileUtils.mv("#{file}.cem_acpt_new", file)
+            else
+              FileUtils.rm("#{file}.cem_acpt_new")
+            end
+          end
+        end
+
+        # Class to parse the /etc/os-release file
         class OSRelease
           attr_reader :properties
 
@@ -21,7 +58,7 @@ module CemAcpt
 
           def parse_string(os_release)
             os_release = os_release.split("\n")
-            os_release = os_release.map { |line| line.split('=', 2) }.reject { |l| l.length != 2 }
+            os_release = os_release.map { |line| line.split('=', 2) }.select { |l| l.length == 2 }
             os_release.map! { |k, v| [k.downcase, v.delete_prefix('"').delete_suffix('"')] }
             os_release.to_h
           end

data/lib/cem_acpt/test_runner/logging.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../logging'
+
+module CemAcpt
+  module TestRunner
+    # Namespace for TestRunner logging wrapper
+    module Logging
+      def use_logger(logger, **prefix_parts)
+        if logger.nil? || !logger.is_a?(CemAcpt::TestRunner::Logging::Logger)
+          CemAcpt::TestRunner::Logging::Logger.new(**prefix_parts)
+        else
+          this_prefix_parts = logger.prefix_parts.dup.merge(prefix_parts)
+          CemAcpt::TestRunner::Logging::Logger.new(**this_prefix_parts)
+        end
+      end
+
+      # Class to handle logging for Runner objects
+      class Logger
+        include CemAcpt::Logging
+
+        attr_reader :prefix_parts
+
+        def initialize(**prefix_parts)
+          @prefix_parts = prefix_parts
+        end
+
+        def log_prefix
+          parts = []
+          parts << @prefix_parts[:test] if @prefix_parts.key?(:test)
+          parts << @prefix_parts[:node] if @prefix_parts.key?(:node)
+          parts << @prefix_parts[:stage] if @prefix_parts.key?(:stage)
+          parts << @prefix_parts[:step] if @prefix_parts.key?(:step)
+          parts.join(': ')
+        end
+
+        def add_prefix_parts(**parts)
+          @prefix_parts.merge!(parts)
+        end
+
+        def debug(msg, no_prefix: false)
+          logger.debug(format_msg(msg, no_prefix))
+        end
+
+        def info(msg, no_prefix: false)
+          logger.info(format_msg(msg, no_prefix))
+        end
+
+        def warn(msg, no_prefix: false)
+          logger.warn(format_msg(msg, no_prefix))
+        end
+
+        def error(msg, no_prefix: false)
+          logger.error(format_msg(msg, no_prefix))
+        end
+
+        def fatal(msg, no_prefix: false)
+          logger.fatal(format_msg(msg, no_prefix))
+        end
+
+        def <<(msg)
+          logger << msg
+        end
+
+        private
+
+        def format_msg(msg, no_prefix)
+          if no_prefix
+            msg
+          else
+            "#{log_prefix}: #{msg}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/test_runner/run_handler.rb

@@ -3,8 +3,8 @@
 require 'concurrent-ruby'
 require 'open3'
 require_relative '../context'
-require_relative '../logging'
 require_relative '../puppet_helpers'
+require_relative 'logging'
 require_relative 'runner'
 
 module CemAcpt
@@ -19,7 +19,7 @@ module CemAcpt
     # creating Runner objects, handling input and output, and exception
     # handling.
     class RunHandler
-      include CemAcpt::Logging
+      include CemAcpt::TestRunner::Logging
 
       attr_accessor :run_context
 
@@ -29,6 +29,7 @@ module CemAcpt
         @module_pkg_path = Concurrent::IVar.new
         @runners = Concurrent::Array.new
         @thread_pool = Concurrent::SimpleExecutorService.new
+        @logger = use_logger(nil, stage: 'RunHandler')
       end
 
       # Gets the overall exit code for all runners
@@ -38,14 +39,14 @@ module CemAcpt
 
       # Runs the acceptance test suites.
       def run
-        logger.info('RUN HANDLER: Creating and starting test runners...')
+        @logger.info('creating and starting test runners...')
         create_runners
-        logger.info("RUN HANDLER: Created #{@runners.length} runners...")
+        @logger.info("created #{@runners.length} runners...")
         @runners.map { |r| @thread_pool.post { r.start } }
         @thread_pool.shutdown
         @thread_pool.wait_for_termination
         @thread_pool = Concurrent::SimpleExecutorService.new
-        logger.info('Test runners have all exited...')
+        @logger.info('test runners have all exited...')
       rescue StandardError => e
         handle_fatal_error(e)
       ensure
@@ -70,17 +71,17 @@ module CemAcpt
       end
 
       def create_runner(node, platform)
-        logger.info("RUN HANDLER: Creating runner for #{node.test_data[:test_name]} on node #{node.node_name}...")
+        @logger.info("creating runner for #{node.test_data[:test_name]} on node #{node.node_name}...")
         runner = CemAcpt::TestRunner::Runner.new(node, @run_context, platform)
         runner || runner_creation_error(node)
       end
 
       def runner_creation_error(node)
         msg = [
-          "Failed to create runner object for node #{node.node_name}.",
+          "failed to create runner object for node #{node.node_name}!",
           "Cannot run test #{node.test_data[:test_name]}",
         ].join(' ')
-        logger.error(msg)
+        @logger.error(msg)
         nil
       end
 
@@ -88,22 +89,22 @@ module CemAcpt
       def handle_test_results
         @runners.each do |runner|
           result = runner.run_result.to_h
-          logger << "::group::{Results for #{runner.node.test_data[:test_name]}}\n"
+          @logger << "::group::{Results for #{runner.node.test_data[:test_name]}}\n"
           if result.key?('summary_line')
-            logger.info("SUMMARY: #{result['summary_line']} for test #{runner.node.test_data[:test_name]}")
+            @logger.info("SUMMARY: #{result['summary_line']} for test #{runner.node.test_data[:test_name]}", no_prefix: true)
           else
             handle_runner_error_results(runner)
-            logger << "::endgroup::\n"
+            @logger << "::endgroup::\n"
             next
           end
           unless runner.test_failures?
-            logger << "::endgroup::\n"
+            @logger << "::endgroup::\n"
             next
           end
 
           if result.key?('examples') # Log errors outside of examples
             if result['examples'].empty? && !result['messages'].empty?
-              logger.error(result['messages'].join("\n"))
+              @logger.error(result['messages'].join("\n"), no_prefix: true)
             else
               handle_example_error_pending_skipped(runner.node.node_name, result['examples'])
             end
@@ -111,7 +112,7 @@ module CemAcpt
             handle_runner_error_results(runner)
           end
           #debug_test_results(runner) if logger.debug?
-          logger << "::endgroup::\n"
+          @logger << "::endgroup::\n"
         end
       end
 
@@ -121,18 +122,18 @@ module CemAcpt
           next if e['status'] == 'passed'
 
           if e['status'] == 'pending'
-            logger.info(test_pending_msg(node_name, e))
+            @logger.info(test_pending_msg(node_name, e), no_prefix: true)
           else
-            logger.error(test_error_msg(node_name, e))
+            @logger.error(test_error_msg(node_name, e), no_prefix: true)
           end
         end
       end
 
       # Handles logging the results of the runners that errored.
       def handle_runner_error_results(runner)
-        logger.error("SUMMARY: Encountered an error with test #{runner.node.test_data[:test_name]} on node #{runner.node.node_name}")
+        @logger.error("SUMMARY: Encountered an error with test #{runner.node.test_data[:test_name]} on node #{runner.node.node_name}", no_prefix: true)
         runner.run_result.to_h.each do |k, v|
-          logger.error("#{k.upcase}: #{v}")
+          @logger.error("#{k.upcase}: #{v}", no_prefix: true)
         end
       end
 
@@ -202,8 +203,8 @@ module CemAcpt
       # Gracefully handles a fatal error and exits the program.
       # @param err [StandardError, Exception] the error that caused the fatal error
       def handle_fatal_error(err)
-        logger.fatal("RUN HANDLER: Fatal error: #{err.message}")
-        logger.debug(err.backtrace.join("\n"))
+        @logger.fatal("fatal error: #{err.message}")
+        @logger.debug(err.backtrace.join("\n"), no_prefix: true)
       end
     end
   end

data/lib/cem_acpt/test_runner/runner.rb

@@ -2,8 +2,8 @@
 
 require 'concurrent-ruby'
 require 'English'
-require_relative '../logging'
 require_relative '../rspec_utils'
+require_relative 'logging'
 require_relative 'runner_result'
 require_relative 'runner_workflow_builder'
 #require_relative 'workflow'
@@ -25,19 +25,15 @@ module CemAcpt
 
     class RunnerProvisionError < RunnerStepError; end
 
-    
-
     # Runner is a class that runs a single acceptance test suite on a single node.
     # It is responsible for managing the lifecycle of the test suite and
     # reporting the results back to the main thread. Runner objects are created
     # by the RunHandler and then, when started, execute their logic in a thread.
     class Runner
-      include CemAcpt::LoggingAsync
+      include CemAcpt::TestRunner::Logging
 
       attr_reader :node, :node_exists, :run_result
 
-      MAX_PROVISION_ATTEMPTS = 3
-
       # @param node [String] the name of the node to run the acceptance test suite on
       # @param ctx [CemAcpt::RunnerCtx] a cem_acpt Ctx (context) object
       # @param module_pkg_path [Concurrent::IVar] the path to the module package
@@ -52,18 +48,19 @@ module CemAcpt
         @provision_start_time = nil
         @node_exists = false
         @run_result = CemAcpt::TestRunner::RunnerResult.new(@node, debug: @debug_mode)
+        @logger = use_logger(nil, stage: 'Runner', node: @node.node_name, test: @node.test_data[:test_name])
         validate!
       end
 
       # Executes test suite steps
       def start
-        async_info("Starting test suite for #{@node.node_name}", log_prefix('RUNNER'))
+        @logger.info('Starting test suite workflow...')
         @workflow = new_workflow
         @workflow.run
         if @workflow.success?
           @run_result = @workflow.last_result
           @workflow.completed_steps.each do |s|
-            async_info("Step '#{s.name}' completed successfully", log_prefix('RUNNER'))
+            @logger.info("Step '#{s.name}' completed successfully")
           end
           true
         else
@@ -72,7 +69,7 @@ module CemAcpt
           false
         end
       rescue StandardError => e
-        step_error_logging(e)
+        step_error_logging(e, :fatal)
         @run_result = CemAcpt::TestRunner::RunnerResult.new(@node, debug: @debug_mode)
         @run_result.from_error(e)
       end
@@ -89,7 +86,7 @@ module CemAcpt
       # Builds a new workflow for the runner
       # @return [CemAcpt::TestRunner::Workflow::Manager] the new workflow
       def new_workflow
-        builder = RunnerWorkflowBuilder.new(@node, config: @context.config)
+        builder = RunnerWorkflowBuilder.new(@node, @context.config, @logger)
         builder.add_provision
         builder.add_sleep(time: 30)
         builder.add_wait_for_node_ssh
@@ -104,13 +101,15 @@ module CemAcpt
         builder.workflow
       end
 
-      def step_error_logging(err)
-        prefix = err.respond_to?(:step) ? log_prefix(err.step.capitalize) : log_prefix('RUNNER')
-        fatal_msg = ["runner failed: #{err.message}"]
-        async_fatal(fatal_msg, prefix)
-        async_debug("Completed steps: #{@completed_steps}", prefix)
-        async_debug("Failed runner backtrace:\n#{err.backtrace.join("\n")}", prefix)
-        async_debug("Failed runner test data: #{@node.test_data}", prefix)
+      def step_error_logging(err, kind = :error)
+        msg = if err.respond_to?(:step)
+                "runner failed on step '#{err.step}': #{err.message}"
+              else
+                "runner failed: #{err.message}"
+              end
+        @logger.send(kind, msg)
+        @logger.debug("failed runner backtrace:\n#{err.backtrace.join("\n")}")
+        @logger.debug("failed runner test data: #{@node.test_data}")
       end
 
       def log_prefix(prefix)

data/lib/cem_acpt/test_runner/runner_workflow_builder.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../logging'
+require_relative 'logging'
 require_relative 'workflow'
 
 module CemAcpt
@@ -9,15 +9,17 @@ module CemAcpt
     # @!attribute [r] workflow
     #   @return [CemAcpt::TestRunner::Workflow::Manager] Workflow object
     class RunnerWorkflowBuilder
-      include CemAcpt::LoggingAsync
+      include CemAcpt::TestRunner::Logging
 
       attr_reader :workflow
 
       # @param node [CemAcpt::Platform::Base] Initialized node object
       # @param config [Hash] Context config hash
-      def initialize(node, config)
+      # @param logger [CemAcpt::TestRunner::Logging::Logger] Logger object
+      def initialize(node, config, logger = nil)
         @node = node
-        @workflow = CemAcpt::TestRunner::Workflow::Manager.new(workflow_manager_opts(config))
+        @logger = use_logger(logger, stage: 'Workflow')
+        @workflow = CemAcpt::TestRunner::Workflow::Manager.new(workflow_manager_opts(config, logger))
         @config = config
       end
 
@@ -28,7 +30,7 @@ module CemAcpt
           retryable: false,
         }
         @workflow.add_step(:sleep, **opts) do |s|
-          log_info("sleeping for #{s.opts[:time]} seconds", s)
+          s.logger.info("sleeping for #{s.opts[:time]} seconds")
           sleep(s.opts[:time])
         end
       end
@@ -104,7 +106,7 @@ module CemAcpt
           }.merge(s.opts[:node].node)
           s.opts[:node_inventory].add(s.opts[:node].node_name, node_desc)
           s.opts[:node_inventory].save
-          log_info("node #{s.opts[:node_name]} saved to inventory", s)
+          s.logger.info("node #{s.opts[:node_name]} saved to inventory")
           s.opts[:node_inventory]
         end
       end
@@ -169,11 +171,11 @@ module CemAcpt
               rspec_cmd.execute(pty: false, log_prefix: "RSPEC: #{@node.test_data[:test_name]}")
               run_result.from_json_file(cmd_opts.format[:json])
             rescue Errno::EIO => e
-              log_error("failed to run rspec: #{@node.test_data[:test_name]}: #{$ERROR_INFO}", s)
+              s.logger.error("failed to run rspec: #{@node.test_data[:test_name]}: #{$ERROR_INFO}")
               run_result.from_error(e)
             rescue StandardError => e
-              log_error("failed to run rspec: #{@node.test_data[:test_name]}: #{e.message}", s)
-              log_debug(e.backtrace.join("\n"), s)
+              s.logger.error("failed to run rspec: #{@node.test_data[:test_name]}: #{e.message}")
+              s.logger.debug(e.backtrace.join("\n"))
               run_result.from_error(e)
             end
           end
@@ -184,53 +186,30 @@ module CemAcpt
       def add_clean_up(force: false, **kwargs)
         opts = {
           node: @node,
-          config: @config[:config],
+          config: @config,
           force: force,
           retryable: kwargs[:retryable] || false,
         }
         @workflow.add_step(:clean_up, **opts) do |s|
           if !force && s.opts[:config].get('no_destroy_nodes')
-            log_info("not destroying node #{s.opts[:node].node_name} because 'no_destroy_nodes' is set to true", s)
+            s.logger.info("not destroying node #{s.opts[:node].node_name} because 'no_destroy_nodes' is set to true")
           else
-            log_info("destroying node #{s.opts[:node].node_name}", s)
+            s.logger.info("destroying node #{s.opts[:node].node_name}")
             s.opts[:node].destroy
-            log_info("node #{s.opts[:node].node_name} destroyed", s)
+            s.logger.info("node #{s.opts[:node].node_name} destroyed")
           end
         end
       end
 
       private
 
-      def log_msg(msg, step)
-        "Step '#{step.name}' on #{@node.node_name}: #{msg}"
-      end
-
-      def log_debug(msg, step)
-        async_debug(log_msg(msg, step))
-      end
-
-      def log_info(msg, step)
-        async_info(log_msg(msg, step))
-      end
-
-      def log_warn(msg, step)
-        async_warn(log_msg(msg, step))
-      end
-
-      def log_error(msg, step)
-        async_error(log_msg(msg, step))
-      end
-
-      def log_fatal(msg, step)
-        async_fatal(log_msg(msg, step))
-      end
-
-      def workflow_manager_opts(config)
+      def workflow_manager_opts(config, logger = nil)
         {
-          retry_max: config[:workflow_retry_max] || 3,
-          retry_delay: config[:workflow_retry_delay] || 0,
-          ignore_failures: config[:workflow_ignore_failures] || false,
-          raise_on_fail: config[:workflow_raise_on_fail] || true,
+          retry_max: config.get('workflow.retry_max') || 3,
+          retry_delay: config.get('workflow.retry_delay') || 0,
+          ignore_failures: config.get('workflow.ignore_failures') || false,
+          raise_on_fail: config.get('workflow.raise_on_fail') || true,
+          logger: logger,
         }
       end
     end

data/lib/cem_acpt/test_runner/workflow/manager.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../logging'
+require_relative '../logging'
 require_relative 'step'
 
 module CemAcpt
@@ -20,7 +20,7 @@ module CemAcpt
       # @!attribute [r] steps
       #   @return [Array<Step>] The steps that are part of this workflow
       class Manager
-        include CemAcpt::LoggingAsync
+        include CemAcpt::TestRunner::Logging
 
         attr_reader :completed_steps, :last_error, :last_result, :retry_max, :retry_delay, :steps
 
@@ -34,6 +34,7 @@ module CemAcpt
           @retry_delay = opts[:retry_delay] || 0
           @ignore_failures = opts[:ignore_failures] || false
           @raise_on_fail = opts[:raise_on_fail] || true
+          @logger = use_logger(opts[:logger], stage: 'Workflow')
           @steps = []
           @workflow_runs = 0
           @last_error = nil
@@ -57,8 +58,8 @@ module CemAcpt
                       else
                         name
                       end
-          step = Step.new(step_name, **kwargs, &block)
-          @steps << StepState.new(step, @steps.length, **kwargs)
+          step = Step.new(step_name, **kwargs.merge(logger: @logger), &block)
+          @steps << StepState.new(step, @steps.length, **kwargs.merge(logger: @logger))
         end
 
         # Run the workflow
@@ -92,6 +93,43 @@ module CemAcpt
 
         private
 
+        def new_logger(logger)
+          if logger.nil?
+            logger
+          else
+            @logger = logger.dup
+            @logger.add_prefix_parts(stage: 'Workflow')
+          end
+        end
+
+        def log(level, msg)
+          if @logger
+            @logger.send(level, msg)
+          else
+            send("async_#{level}".to_sym, msg)
+          end
+        end
+
+        def log_debug(msg)
+          log(:debug, msg)
+        end
+
+        def log_info(msg)
+          log(:info, msg)
+        end
+
+        def log_warn(msg)
+          log(:warn, msg)
+        end
+
+        def log_error(msg)
+          log(:error, msg)
+        end
+
+        def log_fatal(msg)
+          log(:fatal, msg)
+        end
+
         # Handles the result of a step
         # @param [Step] step The step that was run
         # @param [Object] result The result of the step
@@ -100,26 +138,26 @@ module CemAcpt
           @last_result = result unless step.name == :clean_up # Don't overwrite the last result with the clean_up step
           case result
           when :retry_workflow
-            async_warn("Step '#{step.name}' failed and requested a workflow retry")
-            async_debug("Step '#{step.name}' failed with error: #{step.last_error.message}")
-            async_debug("Step '#{step.name}' failed with error: #{step.last_error.backtrace.join("\n")}")
+            log_warn("step '#{step.name}' failed and requested a workflow retry")
+            log_debug("step '#{step.name}' failed with error: #{step.last_error.message}")
+            log_debug("step '#{step.name}' failed with error: #{step.last_error.backtrace.join("\n")}")
             @last_error = step.last_error
             retry_workflow
           when :fail
-            async_warn("Step '#{step.name}' failed")
-            async_debug(step.last_error.message)
-            async_debug(step.last_error.backtrace.join("\n"))
+            log_warn("step '#{step.name}' failed")
+            log_debug(step.last_error.message)
+            log_debug(step.last_error.backtrace.join("\n"))
             @last_error = step.last_error
             if ignore_failures?
-              async_warn("Ignoring failure of step '#{step.name}'")
+              log_warn("ignoring failure of step '#{step.name}'")
               @completed_steps << step
             else
-              async_error("Workflow failed with error: #{@last_error.message}")
+              log_error("failed with error: #{@last_error.message}")
               raise @last_error
             end
           else
-            async_info("Step '#{step.name}' succeeded")
-            async_debug("Step '#{step.name}' returned: #{result}")
+            log_info("step '#{step.name}' succeeded")
+            log_debug("step '#{step.name}' returned: #{result}")
             @completed_steps << step
           end
         end
@@ -128,12 +166,12 @@ module CemAcpt
         # @raise [StandardError] If the workflow is not retryable or has exceeded the maximum number of retries
         def retry_workflow
           if @workflow_runs < @retry_max
-            async_info("Retrying workflow (attempt #{@workflow_runs + 1} of #{@retry_max})")
+            log_info("Retrying workflow (attempt #{@workflow_runs + 1} of #{@retry_max})")
             sleep @retry_delay if @retry_delay > 0
             clean_up
             run
           else
-            async_fatal('Workflow is not retryable or has exceeded the maximum number of retries')
+            log_fatal('Workflow is not retryable or has exceeded the maximum number of retries')
             raise @last_error
           end
         end
@@ -142,7 +180,7 @@ module CemAcpt
         # @return [Step] The default clean_up step
         def default_clean_up
           add_step(:clean_up) do
-            async_info('No clean_up step defined, skipping')
+            log_info('No clean_up step defined, skipping')
             true
           end
           @steps.last

data/lib/cem_acpt/test_runner/workflow/step.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../logging'
+require_relative '../logging'
 
 module CemAcpt
   module TestRunner
@@ -28,9 +28,9 @@ module CemAcpt
       # @!attribute [r] result
       #   @return [Object] The result of the step
       class Step
-        include CemAcpt::LoggingAsync
+        include CemAcpt::TestRunner::Logging
 
-        attr_reader :name, :opts, :result
+        attr_reader :logger, :name, :opts, :result
 
         # @param name [Symbol] The name of the step
         # @param opts [Hash] The options passed to the step
@@ -42,7 +42,7 @@ module CemAcpt
           @block = block
           @result = :not_run
           @failed = false
-          @log_prefix = opts[:log_prefix] || "#{@name.upcase}:"
+          @logger = use_logger(opts[:logger], step: name.to_s.capitalize)
         end
 
         # @return [Boolean] True if the step has been run and failed
@@ -51,27 +51,21 @@ module CemAcpt
         end
 
         # Run the step. This calls and executes the block passed to the constructor.
-        # @param log_prefix [String] The prefix to use when logging the step name
+        # @param start_log [String] The message to log when the step starts
         # @return [Object] The result of the step
-        def run(_log_prefix = 'Running step')
-          async_info(log_msg('Starting step'))
+        def run(start_log = 'starting step')
+          @logger.info(start_log)
           @result = @block.call(self)
-          async_debug(log_msg('SUCCESS'))
+          @logger.debug('SUCCESS')
           @result
         rescue StandardError => e
-          async_debug(log_msg("FAILED: #{e.message}"))
+          @logger.debug("FAILED: #{e.message}")
           @result = StepError.new(@name, e)
           @failed = true
           @result
         ensure
           Thread.pass # Be kind to the scheduler
         end
-
-        private
-
-        def log_msg(msg)
-          [@log_prefix, msg].join(' ')
-        end
       end
 
       # StepState is a class that holds the state of a Step.
@@ -144,11 +138,11 @@ module CemAcpt
         end
 
         # Run the step. This wraps the Step#run method and handles updating the state of the step.
-        # @param log_prefix [String] The prefix to use when logging the step name
+        # @param start_log [String] The message to log when the step starts
         # @return [Object] The result of the step
-        def run(log_prefix = 'Running step')
+        def run(start_log = 'starting step')
           @run_count += 1
-          @last_result = @step.run(log_prefix)
+          @last_result = @step.run(start_log)
           @results << @last_result
           if @last_result.is_a?(StepError)
             handle_error(@last_result)
@@ -178,8 +172,8 @@ module CemAcpt
 
         # Retry running the step
         def retry_step
-          sleep @retry_delay if @retry_delay > 0
-          run("Retrying step (attempt #{@run_count} of #{@retry_max})")
+          sleep @retry_delay if @retry_delay.positive?
+          run("retrying step (attempt #{@run_count + 1} of #{@retry_max})")
         end
       end
     end

data/lib/cem_acpt/test_runner/workflow.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative '../logging'
 require_relative 'workflow/manager'
 require_relative 'workflow/step'
 
@@ -10,206 +9,3 @@ module CemAcpt
     module Workflow; end
   end
 end
-
-# module CemAcpt
-#   module TestRunner
-    
-
-#     # Workflow is a class that manages how steps are executed.
-#     class Workflow
-#       include CemAcpt::LoggingAsync
-
-#       attr_reader :steps, :groups, :group_retry_max, :completed_steps
-
-#       def initialize(init_steps: [], **opts)
-#         raise ArgumentError, 'init_steps must be an Array' unless init_steps.is_a?(Array)
-#         raise ArgumentError, 'init_steps must be an Array of Step objects' unless init_steps.all? { |step| step.is_a?(Step) }
-
-#         @steps = init_steps
-#         @groups = @steps.map(&:group).compact.uniq
-#         @group_retry_max = opts[:group_retry_max] || 3
-#         @group_tries = {}
-#         @last_error = nil
-#         @completed_steps = []
-#       end
-
-#       def add_step(step, order = nil)
-#         raise ArgumentError, 'step must be a Step object' unless step.is_a?(Step)
-
-#         unless order.nil?
-#           @steps.insert(order, step)
-#         else
-#           @steps << step
-#         end
-#       end
-
-#       def add_step_with(name, order = nil, **kwargs, &block)
-#         raise ArgumentError, 'order must be an Integer' unless order.is_a?(Integer) || order.nil?
-#         raise ArgumentError, 'name must be a Symbol' unless name.is_a?(Symbol)
-
-#         unless order.nil?
-#           @steps.insert(order, Step.new(name, **kwargs, &block))
-#         else
-#           @steps << Step.new(name, **kwargs, &block)
-#         end
-#       end
-
-#       def run
-#         current_run_groups = []
-#         @steps.each do |step|
-#           next if step.name == :clean_up
-
-#           group_run_increment(step, current_run_groups)
-#           step.run
-#           @completed_steps << step
-#         end
-#         @completed_steps
-#       rescue StandardError => e
-#         async_error("Workflow failed with error: #{e}")
-#         @last_error = e
-#         raise e
-#       ensure
-#         clean_up
-#       end
-
-#       def success?
-#         (@completed_steps.length == @steps.length) && @completed_steps.none? { |step| step.result.is_a?(StepError) }
-#       end
-
-#       private
-
-#       def group_run_increment(step, current_run_groups = [])
-#         if step.grouped? && !current_run_groups.include?(step.group)
-#           current_run_groups << step.group
-#           if @group_tries[step.group].nil? || @group_tries[step.group].zero?
-#             @group_tries[step.group] = 1
-#           elsif @group_tries[step.group] >= @group_retry_max
-#             raise StepError.new(step, @last_error)
-#           else
-#             @group_tries[step.group] += 1
-#           end
-#         end
-#       end
-
-#       def run_step(step)
-#         result = step.run
-#         #handle_result(step, result)
-#         @completed_steps << step
-#         result
-#       end
-
-#       def handle_result(step, result)
-#         if result.is_a?(StepError)
-#           handle_error(step, result)
-#         else
-#           async_info("Step '#{step.name}' completed successfully")
-#         end
-#       end
-
-#       def handle_error(step, err)
-#         if step.retryable? && step.runs < @retry_max
-#           async_info("Retrying step '#{step.name}' (attempt #{step.runs + 1} of #{@retry_max})")
-#           sleep step.retry_delay if step.retry_delay > 0
-#           run_step(step)
-#         else
-#           async_debug("Step '#{step.name}' is not retryable or has exceeded the maximum number of retries")
-#           raise err if step.raise_on_fail?
-#         end
-#       end
-
-#       def default_clean_up
-#         Step.new(:clean_up, retryable: false, raise_on_fail: true) do
-#           async_info('No clean_up step defined, skipping')
-#         end
-#       end
-
-#       def clean_up
-#         cleanup_step = @steps.find { |step| step.name == :clean_up } || default_clean_up
-#         unless cleanup_step.nil?
-#           cleanup_step.retryable = false # clean_up steps should not be retried
-#           cleanup_step.raise_on_fail = true # clean_up steps should always raise on failure
-#           run_step(cleanup_step)
-#         end
-#       end
-#     end
-
-#     # Step is a class that defines a single step in a Workflow.
-#     class Step
-#       include CemAcpt::LoggingAsync
-
-#       attr_reader :group, :name, :opts, :result, :retry_delay, :retry_max, :runs
-
-#       def initialize(name, **opts, &logic)
-#         @name = name
-#         @logic = logic
-#         @group = opts[:group] || nil
-#         @retryable = opts[:retryable] || false
-#         @retry_delay = opts[:retry_delay] || 0
-#         @retry_max = opts[:retry_max] || 3
-#         @retry_group_on_fail = opts[:retry_group_on_fail] || false
-#         @raise_on_fail = opts[:raise_on_fail] || true
-#         @runs = 0
-#         @opts = opts
-#         @result = :not_run
-#       end
-
-#       def grouped?
-#         !@group.nil?
-#       end
-
-#       def retryable?
-#         @retryable
-#       end
-
-#       def retry_group_on_fail?
-#         @retry_group_on_fail
-#       end
-
-#       def raise_on_fail?
-#         @raise_on_fail
-#       end
-
-#       def retryable=(val)
-#         raise ArgumentError, 'retryable must be a Boolean' unless val.is_a?(TrueClass) || val.is_a?(FalseClass)
-
-#         @retryable = val
-#       end
-
-#       def retry_delay=(val)
-#         raise ArgumentError, 'retry_delay must be an Integer' unless val.is_a?(Integer)
-
-#         @retry_delay = val
-#       end
-
-#       def retry_group_on_fail=(val)
-#         raise ArgumentError, 'retry_group_on_fail must be a Boolean' unless val.is_a?(TrueClass) || val.is_a?(FalseClass)
-
-#         @retry_group_on_fail = val
-#       end
-
-#       def raise_on_fail=(val)
-#         raise ArgumentError, 'raise_on_fail must be a Boolean' unless val.is_a?(TrueClass) || val.is_a?(FalseClass)
-
-#         @raise_on_fail = val
-#       end
-
-#       def run
-#         begin
-#           @runs += 1
-#           async_info("Running step #{@name}...") if @runs == 1
-#           @result = @logic.call(@opts)
-#         rescue StandardError => e
-#           if retryable? && @runs < @retry_max
-#             sleep @retry_delay if @retry_delay > 0
-#             async_info("Retrying step #{@name} (attempt #{@runs + 1} of #{@retry_max})")
-#             run
-#           else
-#             @result = CemAcpt::TestRunner::StepError.new(@name, e)
-#             raise @result if raise_on_fail?
-#           end
-#         end
-#         @result
-#       end
-#     end
-#   end
-# end

data/lib/cem_acpt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CemAcpt
-  VERSION = '0.3.4'
+  VERSION = '0.3.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cem_acpt
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: universal-java-17
 authors:
 - puppetlabs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-30 00:00:00.000000000 Z
+date: 2023-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -190,6 +190,7 @@ files:
 - lib/cem_acpt/spec_helper_acceptance.rb
 - lib/cem_acpt/test_data.rb
 - lib/cem_acpt/test_runner.rb
+- lib/cem_acpt/test_runner/logging.rb
 - lib/cem_acpt/test_runner/run_handler.rb
 - lib/cem_acpt/test_runner/runner.rb
 - lib/cem_acpt/test_runner/runner_result.rb