cem_acpt 0.2.5 → 0.6.1

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

data/lib/cem_acpt/platform/base.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'securerandom'
 require_relative File.join(__dir__, '..', 'image_name_builder')
 require_relative File.join(__dir__, '..', 'logging')
@@ -10,69 +11,57 @@ module CemAcpt::Platform
   class Base
     include CemAcpt::Logging
 
-    attr_reader :config, :test_data, :local_port, :node_name, :image_name
+    attr_reader :test_data, :node_name
 
     # @param conf [CemAcpt::Config] the config object.
     # @param single_test_data [Hash] the test data for the current test.
-    # @param local_port [Integer] the local port to use for the test.
-    def initialize(conf, single_test_data, local_port)
+    def initialize(config, single_test_data)
       raise ArgumentError, 'single_test_data must be a Hash' unless single_test_data.is_a?(Hash)
 
-      @config = conf.get('node_data')
+      @config = config
       @test_data = single_test_data
-      @local_port = local_port
       @node_name = @test_data[:node_name] || random_node_name
-      @image_name = conf.has?('image_name_builder') ? image_name_builder(conf, single_test_data) : @test_data[:image_name]
     end
 
-    # Node should return a hash of all data about a created node.
-    def node
-      raise NotImplementedError, '#node must be implemented by subclass'
+    def to_h
+      {
+        node_name: node_name,
+        image_name: image_name,
+        test_data: test_data,
+        platform_data: platform_data,
+        node_data: node_data,
+      }
     end
 
-    # Provision a node. Will be called asynchronously.
-    def provision
-      raise NotImplementedError, '#provision must be implemented by subclass'
+    def to_json(*args)
+      to_h.to_json(*args)
     end
 
-    # Destroy a node. Will be called asynchronously.
-    def destroy
-      raise NotImplementedError, '#destroy must be implemented by subclass'
+    # Data common to all nodes of the same platform.
+    def platform_data
+      raise NotImplementedError, 'common_data must be implemented by the specific platform module'
     end
 
-    # Tests to see if a node is ready to accept connections from the test suite.
-    def ready?
-      raise NotImplementedError, '#ready? must be implemented by subclass'
+    # Data specific to the current node.
+    def node_data
+      raise NotImplementedError, 'node_data must be implemented by the specific platform module'
     end
 
-    # Upload and install a Puppet module package on the node. Blocking call.
-    def install_puppet_module_package(_module_pkg_path, _remote_path)
-      raise NotImplementedError, '#install_puppet_module_package must be implemented by subclass'
+    # Generates or retrieves an image name from the test data.
+    def image_name
+      @image_name ||= (@config.has?('image_name_builder') ? image_name_builder(@config, test_data) : test_data[:image_name])
     end
 
+    private
+
     # Generates a random node name.
     def random_node_name
-      "acpt-test-#{SecureRandom.hex(10)}"
+      "cem-acpt-#{SecureRandom.hex(12)}"
     end
 
     # Builds an image name if the config specifies to use the image name builder.
     def image_name_builder(conf, tdata)
       @image_name_builder ||= CemAcpt::ImageNameBuilder.new(conf).build(tdata)
     end
-
-    # Returns a command provider specified by the Platform module of the specific platform.
-    def self.command_provider
-      raise NotImplementedError, '#command_provider must be implemented by subclass'
-    end
-
-    # Applies a Puppet manifest on the given node.
-    def self.apply_manifest(_instance_name, _manifest, _opts = {})
-      raise NotImplementedError, '#apply_manifest must be implemented by subclass'
-    end
-
-    # Runs a shell command on the given node.
-    def self.run_shell(_instance_name, _cmd, _opts = {})
-      raise NotImplementedError, '#run_shell must be implemented by subclass'
-    end
   end
 end