cem_acpt 0.2.5 → 0.6.0

data/lib/cem_acpt/goss/api.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'async'
+require 'async/barrier'
+require 'async/http/internet'
+require 'json'
+require_relative 'api/action_response'
+
+module CemAcpt
+  module Goss
+    # Holds methods for interacting with the Goss API running on a test node.
+    module Api
+      class << self
+        # 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.
+        # @param action [Symbol] The action to run.
+        # @return [URI] The URI for the action.
+        def action_uri(host, action)
+          URI("http://#{host}:#{ACTIONS[action.to_sym]}")
+        end
+
+        # Run the specified actions against the specified hosts asynchronously.
+        # @param hosts [Array<String>] 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.
+        # @return [Queue] The queue of results.
+        def run_actions_async(hosts, results: Queue.new, only: [], except: [])
+          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)
+          only.map!(&:to_sym)
+          except.map!(&:to_sym)
+          only_specified = !only.empty?
+          except_specified = !except.empty?
+          Async do
+            internet = Async::HTTP::Internet.new
+            barrier = Async::Barrier.new
+            barrier.async do
+              hosts.each do |host|
+                ACTIONS.keys.each do |action, _|
+                  next if only_specified && !only.include?(action)
+                  next if except_specified && except.include?(action)
+
+                  results << run_action(internet, host, action)
+                end
+              end
+            end
+            barrier.wait
+          ensure
+            internet&.close
+            results.close if results.respond_to?(:close)
+          end
+          results
+        end
+
+        # Run the specified action against the specified host.
+        # @param internet [Async::HTTP::Internet] The Async::HTTP::Internet object to use for the request.
+        # @param host [String] The host to run the action against. This should be
+        #   a public IP address or a DNS-resolvable name.
+        # @param action [Symbol] The action to run.
+        # @return [ActionResponse] The response from the action.
+        def run_action(internet, host, action)
+          uri = action_uri(host, action)
+          response = internet.get(uri.to_s)
+          body = JSON.parse(response.read)
+          ActionResponse.new(host, action, response.status, body)
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/goss.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'goss/api'
+
+module CemAcpt
+  # Holds all the Goss related code
+  module Goss; end
+end

data/lib/cem_acpt/image_name_builder.rb

@@ -41,13 +41,8 @@ module CemAcpt
     # @param test_data [Hash] The test data to use to build the image name.
     # @return [String] The image name.
     def build(test_data)
-      logger.debug 'Building image name...'
-      logger.debug "Using config: #{@config.to_h}"
-      logger.debug "Test data: #{test_data}"
       parts = resolve_parts(test_data)
-      logger.debug "Resolved parts: #{parts}"
       image_name = create_image_name(parts)
-      logger.debug "Created image name: #{image_name}"
       final_image_name = character_substitutions(image_name)
       logger.debug "Final image name: #{final_image_name}"
       final_image_name
@@ -61,10 +56,8 @@ module CemAcpt
     # @return [Array] The parts array with variables resolved.
     def resolve_parts(test_data)
       @config[:parts].each_with_object([]) do |part, ary|
-        logger.debug "Resolving part: #{part}"
         if part.start_with?('$')
           var_path = part[1..-1]
-          logger.debug "Resolving variable path: #{var_path}"
           ary << test_data.dot_dig(var_path)
         else
           ary << part
@@ -77,10 +70,8 @@ module CemAcpt
     # @return [String] The image name.
     def create_image_name(parts)
       image_name = @config[:join_with] ? parts.join(@config[:join_with]) : parts.join
-      logger.debug("Final image name: #{image_name}")
 
       if @config[:validation_pattern]
-        logger.debug "Validating image name: #{image_name}..."
         return image_name if image_name.match?(@config[:validation_pattern])
 
         raise "Image name #{image_name} does not match validation pattern #{@config[:validation_pattern]}"

data/lib/cem_acpt/logging/formatter.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  module Logging
+    module Formatter
+      class << self
+        def valid_format?(log_format)
+          all.any? { |f| f.log_format == log_format.downcase.to_sym }
+        end
+
+        def for(log_format)
+          formatter = all.find { |f| f.log_format == log_format.downcase.to_sym }
+          raise "Unknown log format: #{log_format}" unless formatter
+
+          formatter.get
+        end
+
+        def all
+          @all ||= [FileFormatter.new, JSONFormatter.new, TextFormatter.new, GithubActionFormatter.new]
+        end
+      end      
+
+      class FileFormatter
+        attr_reader :log_format
+
+        def initialize
+          @log_format = :file
+        end
+  
+        def get
+          proc do |severity, datetime, progname, msg|
+            format(severity, datetime, progname, msg)
+          end
+        end
+
+        private
+
+        def format(severity, datetime, progname, msg)
+          "[#{datetime}] #{severity}: #{progname}: #{msg}\n"
+        end
+      end
+
+      class JSONFormatter < FileFormatter
+        def initialize
+          super
+          @log_format = :json
+        end
+
+        private
+
+        def format(severity, datetime, progname, msg)
+          require 'json'
+          {
+            timestamp: datetime,
+            progname: progname,
+            severity: severity,
+            message: msg,
+          }.to_json + "\n"
+        end
+      end
+
+      class TextFormatter < FileFormatter
+        def initialize
+          super
+          @log_format = :text
+        end
+
+        private
+
+        def format(severity, _datetime, progname, msg)
+          "#{severity}: #{progname}: #{msg}\n"
+        end
+      end
+
+      class GithubActionFormatter < FileFormatter
+        SEV_MAP = {
+          'DEBUG' => '::debug::',
+          'INFO' => '::notice::',
+          'WARN' => '::warning::',
+          'ERROR' => '::error::',
+          'FATAL' => '::error::',
+        }.freeze
+
+        def initialize
+          super
+          @log_format = :github_action
+        end
+
+        private
+
+        def format(severity, _datetime, progname, msg)
+          "#{SEV_MAP[severity]}[#{progname}] #{msg}\n"
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/logging.rb

@@ -1,27 +1,50 @@
 # frozen_string_literal: true
 
 require 'logger'
+require 'cem_acpt/logging/formatter'
 
 module CemAcpt
   # Logging for CemAcpt
   module Logging
     LEVEL_MAP = {
-      'debug' => Logger::DEBUG,
-      'info' => Logger::INFO,
-      'warn' => Logger::WARN,
-      'error' => Logger::ERROR,
-      'fatal' => Logger::FATAL,
-      'unknown' => Logger::UNKNOWN,
+      'debug' => ::Logger::DEBUG,
+      'info' => ::Logger::INFO,
+      'warn' => ::Logger::WARN,
+      'error' => ::Logger::ERROR,
+      'fatal' => ::Logger::FATAL,
+      'unknown' => ::Logger::UNKNOWN,
     }
 
     # Delegator class for when you want to log to multiple devices
     # at the same time, such as STDOUT and a file.
-    # @param loggers [::Logger] one or more instances of Logger
+    # @param loggers [Logger] one or more instances of CemAcpt::Logging::Logger
     class MultiLogger
+      # @param configs [Array<Hash>] an array of hashes containing the
+      #   configuration for each logger. Each hash must contain the keys
+      #   :logdev, :shift_age, and :shift_size. The values for these keys
+      #   are passed to the Logger.new method. Any other keys and values
+      #   are passed to the Logger.new method as keyword arguments.
+      # @return [MultiLogger] a new instance of MultiLogger
+      def self.from_logger_configs(configs)
+        return if configs.nil? || configs.empty?
+
+        loggers = configs.map do |config|
+          CemAcpt::Logging::Logger.new(config[:logdev],
+                                       config[:shift_age],
+                                       config[:shift_size],
+                                       **config.except(:logdev, :shift_age, :shift_size))
+        end
+        new(*loggers)
+      end
+
       def initialize(*loggers)
         @loggers = loggers
       end
 
+      def logger_configs
+        @loggers.map(&:config_hash)
+      end
+
       def method_missing(m, *args, &block)
         if @loggers.all? { |l| l.respond_to?(m) }
           @loggers.map { |l| l.send(m, *args, &block) }
@@ -35,6 +58,137 @@ module CemAcpt
       end
     end
 
+    # Delagator class for the standard Ruby Logger class.
+    # This class is used to ensure the Github Actions formatter
+    # correctly formats the log output when using the standard
+    # Ruby Logger class methods such as #info, #debug, etc.
+    class Logger < ::Logger
+      attr_reader :config_hash
+      attr_accessor :trap_context
+
+      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?)
+        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
+        @trap_context = false # If true, will not use the standard Logger methods and will write directly to the logdev
+        @verbose = false
+      end
+
+      def set_verbose(value)
+        raise ArgumentError, 'value must be a boolean' unless [true, false].include?(value)
+
+        @verbose = value
+      end
+
+      def verbose(progname = nil, &block)
+        return unless @verbose
+
+        debug(progname, &block)
+      end
+
+      def debug(progname = nil, &block)
+        return if log_trap_context('debug', progname, &block)
+        return if log_ci_mode('debug', progname, &block)
+
+        super
+      end
+
+      def info(progname = nil, &block)
+        return if log_trap_context('info', progname, &block)
+        return if log_ci_mode('info', progname, &block)
+
+        super
+      end
+
+      def warn(progname = nil, &block)
+        return if log_trap_context('warn', progname, &block)
+        return if log_ci_mode('warn', progname, &block)
+
+        super
+      end
+
+      def error(progname = nil, &block)
+        return if log_trap_context('error', progname, &block)
+        return if log_ci_mode('error', progname, &block)
+
+        super
+      end
+
+      def fatal(progname = nil, &block)
+        return if log_trap_context('fatal', progname, &block)
+        return if log_ci_mode('fatal', progname, &block)
+
+        super
+      end
+
+      # Wraps the given block in a Github Actions group if in CI mode
+      # @param name [String] the name of the group
+      def with_ci_group(name)
+        return yield unless @ci_mode
+
+        self.<< "::group::#{name}\n"
+        yield
+      ensure
+        self.<< "::endgroup::\n" if @ci_mode
+      end
+
+      private
+
+      # Can't use the standard Logger methods when in trap context
+      # because they don't work. So we have to write directly to the
+      # raw logdev. Unlike the standard Logger methods, there is no
+      # Mutex lock, so messages are not guaranteed to be in order.
+      # This is necessary in the trap context because using a Mutex
+      # lock in a trap context will cause a deadlock.
+      def log_trap_context(severity, progname = nil, &block)
+        return false unless @trap_context && level <= LEVEL_MAP[severity]
+
+        if @raw_logdev.respond_to?(:puts)
+          @raw_logdev.puts(ci_format(severity, false, progname, &block))
+        elsif @raw_logdev.respond_to?(:write)
+          @raw_logdev.write(ci_format(severity, true, progname, &block))
+        else
+          # Default to logging to STDERR
+          $stderr.puts(ci_format(severity, false, progname, &block))
+        end
+        true
+      end
+
+      # CI mode uses << instead of the standard Logger methods
+      # because Github Actions wants messages to be echoed. This
+      # is a way to ensure that, in the event of using a multi-logger
+      # with a standard Logger, the CI mode messages are still
+      # formatted correctly.
+      def log_ci_mode(severity, progname = nil, &block)
+        return false unless @ci_mode && level <= LEVEL_MAP[severity]
+
+        self.<<(ci_format(severity, true, progname, &block))
+        true
+      end
+
+      # Formats the log message for CI mode, translating the severity
+      # level to the correct format for Github Actions and adding
+      # the colon separators.
+      def ci_format(severity, newline = true, progname = nil, &block)
+        sev = if severity == 'fatal'
+                'error'
+              elsif severity == 'warn'
+                'warning'
+              elsif severity == 'info'
+                'notice'
+              else
+                severity
+              end
+        block_message = block_given? ? block.call : nil
+        base = [progname, block_message].compact.join(': ')
+        return if base.empty?
+
+        newline ? "::#{sev}::#{base}\n" : "::#{sev}::#{base}"
+      end
+    end
+
     class << self
       def new_logger(*logdevs, **configs)
         new_configs = current_log_config.merge(configs.reject { |_, v| v.nil? })
@@ -57,14 +211,9 @@ module CemAcpt
 
       # Exposes a logger instance. Will either use the currently set logger or
       # create a new one.
-      # @return [Logger]
+      # @return [MultiLogger]
       def logger
-        @logger ||= Logger.new(
-          current_log_config[:logdev],
-          current_log_config[:shift_age],
-          current_log_config[:shift_size],
-          **current_log_config.reject { |k, _| %i[logdev shift_age shift_size].include?(k) }
-        )
+        @logger ||= new_logger($stdout)
       end
 
       # Shortcut method for logger.level
@@ -92,41 +241,7 @@ module CemAcpt
       # @param f [Symbol] the log format style to set
       # @return [Proc] the proc to be passed to Logger#formatter=
       def new_log_formatter(f)
-        case f.downcase.to_sym
-        when :json
-          require 'json'
-          @current_log_format = :json
-          proc do |severity, datetime, progname, msg|
-            {
-              timestamp: datetime,
-              progname: progname,
-              severity: severity,
-              message: msg,
-            }.to_json + "\n"
-          end
-        when :text
-          @current_log_format = :text
-          proc do |severity, _datetime, _progname, msg|
-            "#{severity} - #{msg}\n"
-          end
-        when :github_action
-          @current_log_format = :github_action
-          sev_map = {
-            'DEBUG' => '::debug::',
-            'INFO' => '::notice::',
-            'WARN' => '::warning::',
-            'ERROR' => '::error::',
-            'FATAL' => '::error::',
-          }
-          proc do |severity, _datetime, _progname, msg|
-            "#{sev_map[severity]}{#{msg}}\n"
-          end
-        else
-          @current_log_format = :file
-          proc do |severity, datetime, _progname, msg|
-            "[#{datetime}] #{severity}: #{msg}\n"
-          end
-        end
+        CemAcpt::Logging::Formatter.for(f)
       end
 
       # Returns the current log config if set, or the default if not.
@@ -134,15 +249,14 @@ module CemAcpt
       def current_log_config
         return @log_config if @log_config
 
-        formatter = new_log_formatter(current_log_format)
         @log_config = {
           logdev: $stdout,
           shift_age: 'o',
           shift_size: 1_048_576,
-          level: Logger::INFO,
+          level: ::Logger::INFO,
           progname: 'CemAcpt',
           datetime_format: '%Y%m%dT%H%M%S%z',
-          formatter: formatter,
+          formatter: current_log_format,
         }
         @log_config
       end
@@ -177,12 +291,12 @@ module CemAcpt
           @log_config[:logdev] = $stdout
           logger.warn("Unknown log target: #{logdev.inspect}, using STDOUT")
         end
-        @logger = Logger.new(
+        @logger = MultiLogger.new(Logger.new(
           @log_config[:logdev],
           @log_config[:shift_age],
           @log_config[:shift_size],
           **@log_config.reject { |k, _| %i[logdev shift_age shift_size].include?(k) },
-        )
+        ))
       end
     end
 
@@ -260,92 +374,4 @@ module CemAcpt
       CemAcpt::Logging.new_log_config(logdev: logdev, shift_age: shift_age, shift_size: shift_size, level: level, formatter: formatter, datetime_format: datetime_format)
     end
   end
-
-  module LoggingAsync
-    require 'concurrent-ruby'
-
-    class << self
-      def log_write_thread
-        @log_write_thread ||= Concurrent::SingleThreadExecutor.new
-      end
-
-      def async_debug(message, prefix = nil)
-        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
-        CemAcpt::Logging.logger.debug(msg)
-      end
-
-      def async_info(message, prefix = nil)
-        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
-        CemAcpt::Logging.logger.info(msg)
-      end
-
-      def async_warn(message, prefix = nil)
-        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
-        CemAcpt::Logging.logger.warn(msg)
-      end
-
-      def async_error(message, prefix = nil)
-        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
-        CemAcpt::Logging.logger.error(msg)
-      end
-
-      def async_fatal(message, prefix = nil)
-        msg = prefix.nil? || prefix.empty? ? message : "#{prefix} #{message}"
-        CemAcpt::Logging.logger.fatal(msg)
-      end
-    end
-
-    # Provides class method wrappers for logging methods
-    def self.included(base)
-      class << base
-        def log_write_thread
-          CemAcpt::LoggingAsync.log_write_thread
-        end
-
-        def async_debug(message, prefix = nil)
-          CemAcpt::LoggingAsync.async_debug(message, prefix)
-        end
-
-        def async_info(message, prefix = nil)
-          CemAcpt::LoggingAsync.async_info(message, prefix)
-        end
-
-        def async_warn(message, prefix = nil)
-          CemAcpt::LoggingAsync.async_warn(message, prefix)
-        end
-
-        def async_error(message, prefix = nil)
-          CemAcpt::LoggingAsync.async_error(message, prefix)
-        end
-
-        def async_fatal(message, prefix = nil)
-          CemAcpt::LoggingAsync.async_fatal(message, prefix)
-        end
-      end
-    end
-
-    def log_write_thread
-      CemAcpt::LoggingAsync.log_write_thread
-    end
-
-    def async_debug(message, prefix = nil)
-      CemAcpt::LoggingAsync.async_debug(message, prefix)
-    end
-
-    def async_info(message, prefix = nil)
-      CemAcpt::LoggingAsync.async_info(message, prefix)
-    end
-
-    def async_warn(message, prefix = nil)
-      CemAcpt::LoggingAsync.async_warn(message, prefix)
-    end
-
-    def async_error(message, prefix = nil)
-      CemAcpt::LoggingAsync.async_error(message, prefix)
-    end
-
-    def async_fatal(message, prefix = nil)
-      CemAcpt::LoggingAsync.async_fatal(message, prefix)
-    end
-  end
 end