cem_acpt 0.2.6-universal-java-17

data/lib/cem_acpt/logging.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+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,
+    }
+
+    # 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
+    class MultiLogger
+      def initialize(*loggers)
+        @loggers = loggers
+      end
+
+      def method_missing(m, *args, &block)
+        if @loggers.all? { |l| l.respond_to?(m) }
+          @loggers.map { |l| l.send(m, *args, &block) }
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(m, include_private = false)
+        @loggers.all? { |l| l.respond_to?(m) } || super
+      end
+    end
+
+    class << self
+      def new_logger(*logdevs, **configs)
+        new_configs = current_log_config.merge(configs.reject { |_, v| v.nil? })
+        if new_configs.key?(:level) && !LEVEL_MAP.values.include?(new_configs[:level])
+          new_configs[:level] = LEVEL_MAP[new_configs[:level].downcase]
+        end
+        loggers = logdevs.map do |dev|
+          logdev = dev.is_a?(String) ? $stdout : dev
+          logger = Logger.new(
+            logdev,
+            new_configs[:shift_age],
+            new_configs[:shift_size],
+            **new_configs.reject { |k, _| %i[logdev shift_age shift_size].include?(k) },
+          )
+          logger.reopen(dev) if dev.is_a?(String)
+          logger
+        end
+        @logger = CemAcpt::Logging::MultiLogger.new(*loggers)
+      end
+
+      # Exposes a logger instance. Will either use the currently set logger or
+      # create a new one.
+      # @return [Logger]
+      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) }
+        )
+      end
+
+      # Shortcut method for logger.level
+      # @return [Logger::Severity]
+      def current_log_level
+        logger.level
+      end
+
+      # Shortcut method to set logger.level
+      # @param level [String] the log level to set
+      def new_log_level(level)
+        raise ArgumentError, 'Log level not recognized' unless LEVEL_MAP[level.downcase]
+
+        @logger.level = LEVEL_MAP[level.downcase]
+      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
+        @current_log_format ||= :text
+      end
+
+      # Sets the current log format style and returns a proc to be passed to
+      # Logger#formatter=
+      # @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
+      end
+
+      # Returns the current log config if set, or the default if not.
+      # @return [Hash] the current log config
+      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,
+          progname: 'CemAcpt',
+          datetime_format: '%Y%m%dT%H%M%S%z',
+          formatter: formatter,
+        }
+        @log_config
+      end
+
+      # Creates a new log config hash and a new Logger instance using that config and sets
+      # the new Logger instance as the current logger. NO DEFAULT VALUES ARE SET.
+      # @param logdev [String, IO] the log device to use. If 'stdout' or 'stderr' are passed,
+      #   the respective IO object will be used. Otherwise, Strings will be treated as file paths.
+      #   If an IO object is passed, it will be used directly.
+      #   If no logdev is passed, or an invalid logdev is passed, the default is $stdout.
+      # @param shift_age [String] the log rotation age
+      # @param shift_size [Integer] the log rotation size
+      # @param level [Logger::Severity] the log level
+      # @param formatter [Proc] the log formatter
+      # @param datetime_format [String] the datetime format
+      def new_log_config(logdev: nil, shift_age: nil, shift_size: nil, level: nil, formatter: nil, datetime_format: nil)
+        @log_config[:shift_age] = shift_age if shift_age
+        @log_config[:shift_size] = shift_size if shift_size
+        @log_config[:level] = level if level
+        @log_config[:formatter] = formatter if formatter
+        @log_config[:datetime_format] = datetime_format if datetime_format
+        case logdev
+        when 'stdout'
+          @log_config[:logdev] = $stdout
+        when 'stderr'
+          @log_config[:logdev] = $stderr
+        when String
+          @log_config[:logdev] = target
+        when IO
+          @log_config[:logdev] = logdev
+        else
+          @log_config[:logdev] = $stdout
+          logger.warn("Unknown log target: #{logdev.inspect}, using STDOUT")
+        end
+        @logger = 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
+
+    # Provides class method wrappers for logging methods
+    def self.included(base)
+      class << base
+        def new_logger(*logdevs, **configs)
+          CemAcpt::Logging.new_logger(*logdevs, **configs)
+        end
+
+        def logger
+          CemAcpt::Logging.logger
+        end
+
+        def current_log_level
+          CemAcpt::Logging.current_log_level
+        end
+
+        def new_log_level(level)
+          CemAcpt::Logging.new_log_level(level)
+        end
+
+        def current_log_format
+          CemAcpt::Logging.current_log_format
+        end
+
+        def new_log_formatter(f)
+          CemAcpt::Logging.new_log_formatter(f)
+        end
+
+        def current_log_config
+          CemAcpt::Logging.current_log_config
+        end
+
+        def new_log_config(logdev: nil, shift_age: nil, shift_size: nil, level: nil, formatter: nil, datetime_format: nil)
+          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
+    end
+
+    def new_logger(*logdevs, **configs)
+      CemAcpt::Logging.new_logger(*logdevs, **configs)
+    end
+
+    # Exposes the logger instance
+    def logger
+      CemAcpt::Logging.logger
+    end
+
+    # Exposes the current log level
+    def current_log_level
+      CemAcpt::Logging.current_log_level
+    end
+
+    # Exposes setting the log level
+    def new_log_level(level)
+      CemAcpt::Logging.new_log_level(level)
+    end
+
+    def current_log_format
+      CemAcpt::Logging.current_log_format
+    end
+
+    def new_log_formatter(f)
+      CemAcpt::Logging.new_log_formatter(f)
+    end
+
+    # Exposes the current log config
+    def current_log_config
+      CemAcpt::Logging.current_log_config
+    end
+
+    # Exposes setting a new log config
+    def new_log_config(logdev: nil, shift_age: nil, shift_size: nil, level: nil, formatter: nil, datetime_format: nil)
+      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/cmd.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module CemAcpt::Platform
+  require_relative File.join(__dir__, '..', '..', 'logging.rb')
+
+  class CmdError < StandardError; end
+
+  # Base class for command providers. Provides an API for subclasses to implement.
+  class CmdBase
+    include CemAcpt::Logging
+
+    attr_reader :env
+
+    def initialize(*_args, env: {}, **_kwargs)
+      @env = env
+    end
+
+    def local_exec(*_args, **_kwargs)
+      raise NotImplementedError, '#local_exec must be implemented by a subclass'
+    end
+
+    def ssh(_instance_name, _command, _ignore_command_errors: false, _opts: {})
+      raise NotImplementedError, '#ssh must be implemented by a subclass'
+    end
+
+    def scp_upload(_instance_name, _local, _remote, _scp_opts: {}, _opts: {})
+      raise NotImplementedError, '#scp_upload must be implemented by a subclass'
+    end
+
+    def scp_download(_instance_name, _local, _remote, _scp_opts: {}, _opts: {})
+      raise NotImplementedError, '#scp_download must be implemented by a subclass'
+    end
+
+    def ssh_ready?(_instance_name, _timeout = 300, _opts: {})
+      raise NotImplementedError, '#ssh_ready? must be implemented by a subclass'
+    end
+
+    def apply_manifest(_instance_name, _manifest, _opts: {})
+      raise NotImplementedError, '#create_manifest_on_node must be implemented by a subclass'
+    end
+
+    def run_shell(_instance_name, _command, _opts: {})
+      raise NotImplementedError, '#run_shell must be implemented by a subclass'
+    end
+
+    def trim_output(output)
+      if output.include?("\n")
+        output.split("\n").map(&:strip).reject(&:empty?).join("\n")
+      else
+        output.strip
+      end
+    end
+
+    def with_timed_retry(timeout = 300)
+      return unless block_given?
+
+      last_error = nil
+      start_time = Time.now
+      while Time.now - start_time < timeout
+        begin
+          output = yield
+          return output
+        rescue StandardError => e
+          last_error = e
+          sleep(10)
+        end
+      end
+      raise last_error
+    end
+  end
+end

data/lib/cem_acpt/platform/base.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require_relative File.join(__dir__, '..', 'image_name_builder')
+require_relative File.join(__dir__, '..', 'logging')
+
+module CemAcpt::Platform
+  # Base class for all platform classes. This class provides an API for
+  # interacting with the underlying platform.
+  class Base
+    include CemAcpt::Logging
+
+    attr_reader :config, :test_data, :local_port, :node_name, :image_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)
+      raise ArgumentError, 'single_test_data must be a Hash' unless single_test_data.is_a?(Hash)
+
+      @config = conf.get('node_data')
+      @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'
+    end
+
+    # Provision a node. Will be called asynchronously.
+    def provision
+      raise NotImplementedError, '#provision must be implemented by subclass'
+    end
+
+    # Destroy a node. Will be called asynchronously.
+    def destroy
+      raise NotImplementedError, '#destroy must be implemented by subclass'
+    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'
+    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'
+    end
+
+    # Generates a random node name.
+    def random_node_name
+      "acpt-test-#{SecureRandom.hex(10)}"
+    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