cem_acpt 0.2.6-universal-java-17

data/lib/cem_acpt/bootstrap/operating_system/rhel_family.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# Currently unused in this implementation.
+module CemAcpt::Bootstrap::OperatingSystem
+  # This module holds methods used by Bootstrap for RHEL-family operating systems
+  module RhelFamily
+    def puppet_agent_repo
+      "https://yum.puppet.com/#{@collection}-release-el-#{@major_version}.noarch.rpm"
+    end
+
+    def package_manager
+      return 'dnf' if @major_version.to_i >= 8
+
+      'yum'
+    end
+
+    def rvm_deps
+      [
+        'kernel-devel',
+        'gcc',
+        'gcc-c++',
+        'make',
+        'augeas',
+        'augeas-devel',
+        'patch',
+        'readline',
+        'readline-devel',
+        'zlib',
+        'zlib-devel',
+        'libffi-devel',
+        'openssl-devel',
+        'bzip2',
+        'autoconf',
+        'automake',
+        'libtool',
+        'bison',
+        'sqlite-devel',
+      ]
+    end
+
+    def repo_installs(repos, sudo: true)
+      return if repos.nil? || repos.empty?
+
+      cmd = [
+        repo_install_cmd(repos, sudo: sudo),
+        repo_install_verify_cmd(repos, sudo: sudo),
+      ].join(' && ')
+      "#{cmd} | sudo tee -ai #{@log_file}"
+    end
+
+    def package_installs(packages, sudo: true)
+      return if packages.nil? || packages.empty?
+
+      packages += rvm_deps
+      cmd = [
+        package_install_cmd(packages, sudo: sudo),
+        package_install_verify_cmd(packages, sudo: sudo),
+      ].join(' && ')
+      "#{cmd} | sudo tee -ai #{@log_file}"
+    end
+
+    def service_starts(services, sudo: true)
+      return if services.nil? || services.empty?
+
+      cmd = [
+        #service_start_verify_existance_cmd(services, sudo: sudo),
+        service_start_cmd(services, sudo: sudo),
+      ].join(' && ')
+      "#{cmd} | sudo tee -ai #{@log_file}"
+    end
+
+    def repo_install_cmd(repos, sudo: true)
+      cmd = []
+      cmd << 'sudo' if sudo
+      cmd << 'rpm -Uv'
+      repos.each { |r| cmd << r }
+      cmd.join(' ')
+    end
+
+    def repo_install_verify_cmd(repos, sudo: true)
+      cmd = []
+      cmd << 'sudo' if sudo
+      cmd << 'rpm -q'
+      repos.each { |r| cmd << r }
+      cmd.join(' ')
+    end
+
+    def package_install_cmd(packages, sudo: true)
+      cmd = []
+      cmd << 'sudo' if sudo
+      cmd << "#{package_manager} install #{package_install_cmd_opts}"
+      packages.each { |p| cmd << p }
+      cmd << package_install_cmd_output_format
+      cmd.join(' ')
+    end
+
+    def package_install_verify_cmd(packages, sudo: true)
+      cmd = []
+      cmd << 'sudo' if sudo
+      cmd << "#{package_manager} list installed"
+      packages.each { |p| cmd << p }
+      cmd.join(' ')
+    end
+
+    def package_install_cmd_opts
+      '-y'
+    end
+
+    def package_install_cmd_output_format
+      '| tr "\n" "#" | sed -e \'s/# / /g\' | tr "#" "\n"'
+    end
+
+    def service_start_cmd(services, sudo: true)
+      cmd = []
+      cmd << 'sudo' if sudo
+      cmd << 'systemctl start'
+      services.each { |s| cmd << s }
+      cmd.join(' ')
+    end
+
+    def service_start_verify_existance_cmd(services, sudo: true)
+      cmd = []
+      cmd << 'sudo' if sudo
+      cmd << 'systemctl list-units --type=service'
+      services.each { |s| cmd << s }
+      cmd.join(' ')
+    end
+  end
+end

data/lib/cem_acpt/bootstrap/operating_system.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Currently unused in this implementation.
+module CemAcpt::Bootstrap::OperatingSystem
+  class Error < StandardError; end
+
+  # Currently unused in this implementation.
+  def use_os(os)
+    case os
+    when %r{^(centos|rhel)$}
+      require_relative 'operating_system/rhel_family'
+      self.class.include CemAcpt::Bootstrap::OperatingSystem::RhelFamily
+    else
+      raise Error, "Operating system #{os} is not supported"
+    end
+  end
+end

data/lib/cem_acpt/bootstrap.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Bootstrap provides a method for bootstrapping test nodes.
+# Currently unused in this implementation.
+module CemAcpt::Bootstrap
+  require_relative 'bootstrap/bootstrapper'
+
+  def self.run(instance_name, instance_image, cmd_provider, collection: 'puppet7', repos: [], packages: [], services: [], commands: [], cmd_provider_args: {})
+    bootstrapper = CemAcpt::Bootstrap::Bootstrapper.new(instance_name, instance_image, cmd_provider, collection: 'puppet7', repos: [], packages: [], services: [], commands: [], cmd_provider_args: {})
+    bootstrapper.run
+  end
+end

data/lib/cem_acpt/context.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative 'platform'
+require_relative 'utils'
+require_relative 'shared_objects'
+require_relative 'test_data'
+require_relative 'test_runner/run_handler'
+require_relative 'logging'
+
+module CemAcpt
+  # Context provides the context in which the RunHandler creates and starts Runners.
+  module Context
+    class ContextError < StandardError; end
+
+    class << self
+      include CemAcpt::Logging
+
+      KEY_PATH = File.join([ENV['HOME'], '.ssh', 'acpt_test_key']).freeze
+      KH_PATH = File.join([ENV['HOME'], '.ssh', 'acpt_test_known_hosts']).freeze
+
+      def log(msg, level = :info)
+        real_msg = "CONTEXT: #{msg}"
+        logger.send(level, real_msg)
+      end
+
+      # Builds the Puppet module package
+      # @param opts [Hash] config opts
+      # @return [String] The path to the Puppet module package
+      def build_module_package(opts = {})
+        module_dir = opts[:module_dir] || __dir__
+        pkg_path = CemAcpt::Utils::Puppet.build_module_package(module_dir)
+        log("Module package built at #{pkg_path}")
+        pkg_path
+      end
+
+      # Creates a SSH key and a SSH known hosts file for the acceptance test suite
+      def new_test_ssh_key
+        log('Creating ephemeral SSH key and known hosts file for acceptance test suites...')
+        @ssh_priv_key, @ssh_pub_key = CemAcpt::Utils::SSH.ephemeral_ssh_key
+        @ssh_known_hosts = CemAcpt::Utils::SSH.acpt_known_hosts
+        CemAcpt::Utils::SSH.set_ssh_file_permissions(@ssh_priv_key, @ssh_pub_key, @ssh_known_hosts)
+        log('Successfully created SSH files...')
+        log("SSH private key: #{@ssh_priv_key}", :debug)
+        log("SSH public key: #{@ssh_pub_key}", :debug)
+        log("SSH known hosts: #{@ssh_known_hosts}", :debug)
+      end
+
+      # Deletes acceptance test suite SSH files
+      def clean_test_ssh_key
+        log('Deleting ephemeral ssh keys and acpt_known_hosts if they exist...')
+        [@ssh_priv_key, @ssh_pub_key, @ssh_known_hosts].map { |f| File.delete(f) if File.exist?(f) }
+      end
+
+      # Prints a period to the terminal every 5 seconds in a single line to keep the terminal
+      # alive. This is used when running in CI mode. Does nothing unless the option `:CI` is
+      # `true`, or the environment variables CI or GITHUB_ACTION are set to a truthy value.
+      # @param opts [Hash] config opts
+      def keep_terminal_alive(opts = {})
+        @keep_terminal_alive = if opts[:CI] || ENV['CI'] || ENV['GITHUB_ACTION']
+                                 CemAcpt::Utils::Terminal.keep_terminal_alive
+                               end
+      end
+
+      def clean_up_test_suite(opts)
+        @ctx.node_inventory.clear!
+        @ctx.node_inventory.clean_local_files
+        clean_test_ssh_key unless opts[:no_ephemeral_ssh_key]
+        @run_handler&.destroy_test_nodes
+        @keep_terminal_alive&.kill
+      end
+    end
+
+    # Creates a context (CemAcpt::Context::Ctx) object for the RunHandler to create and start Runners.
+    # Provides the following objects for the Runners: a config object,
+    # the test data hash, the node inventory, and the local port allocator.
+    # Additionally, it creates the platform-specific node objects for each
+    # test suite in the test data. It then calls the provided block with
+    # the context objects nodes, config, test_data, and node_inventory.
+    # @param config_opts [Hash] the config options
+    def self.with(**opts)
+      @opts = opts
+      @start_time = Time.now
+      raise CemAcpt::Context::ContextError, 'CemAcpt::Context.with requires a block' unless block_given?
+
+      config_file = @opts[:config_file] || File.expand_path('./cem_acpt_config.yaml')
+      logger.info("Running acceptance test suite at #{@start_time}")
+      logger.debug("Config opts: #{@opts}")
+      logger.debug("Config file: #{config_file}")
+      logger.info("Using module directory: #{@opts[:module_dir]}")
+      keep_terminal_alive(@opts)
+      Dir.chdir(opts[:module_dir]) do
+        new_test_ssh_key unless @opts[:no_ephemeral_ssh_key]
+        pkg_path = build_module_package(@opts)
+        @ctx = CemAcpt::Context::Ctx.new(opts: @opts, config_file: config_file, module_package_path: pkg_path)
+        logger.debug("Created Ctx object #{@ctx}")
+        @run_handler = CemAcpt::TestRunner::RunHandler.new(@ctx)
+        logger.debug("Created RunHandler object #{@run_handler}")
+        yield @run_handler
+      end
+      @exit_code = @run_handler.exit_code
+    rescue StandardError => e
+      logger.fatal("Acceptance test suite encountered an error: #{e.message}")
+      logger.fatal(e.backtrace.join("\n"))
+      @exit_code = 1
+    ensure
+      clean_up_test_suite(@opts)
+      total_minutes = ((Time.now - @start_time) / 60).round
+      logger.info("Test suite finished in ~#{total_minutes} minutes")
+      @exit_code || 1
+    end
+
+    # Ctx holds the context objects for the RunHandler to create and start Runners.
+    class Ctx
+      attr_reader :config, :test_data, :module_package_path, :node_inventory, :local_port_allocator
+
+      def initialize(opts: nil, config_file: nil, module_package_path: nil)
+        @config = CemAcpt::Config.new.load(opts: opts, config_file: config_file)
+        @test_data = CemAcpt::TestData.acceptance_test_data(@config)
+        @module_package_path = module_package_path
+        @node_inventory = CemAcpt::NodeInventory.new
+        @local_port_allocator = CemAcpt::LocalPortAllocator.new
+        prep_environment
+      end
+
+      def nodes
+        return @nodes if defined?(@nodes)
+
+        raise CemAcpt::Error, 'No platform(s) specified' unless @config.has?('platform') || @config.has?('platforms')
+
+        @nodes = nodes_from_platforms
+        @nodes
+      end
+
+      private
+
+      def prep_environment
+        @node_inventory.clean_local_files
+      end
+
+      def nodes_from_platforms
+        nodes = {}
+        if @config.has?('platform')
+          nodes[@config.get('platform')] = CemAcpt::Platform.use(@config.get('platform'), @config, @test_data, @local_port_allocator)
+        elsif @config.has?('platforms')
+          config.get('platforms').each do |platform|
+            nodes[platform] = CemAcpt::Platform.use(platform, @config, @test_data, @local_port_allocator)
+          end
+        end
+        nodes
+      end
+    end
+  end
+end

data/lib/cem_acpt/core_extensions.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+# This module holds extensions to Ruby and the Ruby stdlib
+# Extensions related to deep_freeze were pulled from: https://gist.github.com/steakknife/1a37057b3b8539f4aca3
+module CemAcpt::CoreExtensions
+  # DeepFreeze recursively freezes all keys and values in a hash
+  # Currently unused, but was used at one point and may be useful again
+  module DeepFreeze
+    # Holds deep_freeze extensions to Kernel
+    module Kernel
+      alias deep_freeze freeze
+      alias deep_frozen? frozen?
+    end
+
+    # Holds deep_freeze extensions to Enumerable
+    module Enumerable
+      def deep_freeze
+        unless @deep_frozen
+          each(&:deep_freeze)
+          @deep_frozen = true
+        end
+        freeze
+      end
+
+      def deep_frozen?
+        !!@deep_frozen
+      end
+    end
+
+    # Holds deep_freeze extensions to Hash
+    module Hash
+      def deep_freeze
+        transform_values! do |value|
+          value.respond_to?(:deep_freeze) ? value.deep_freeze : value.freeze
+        end
+        freeze
+        @deep_frozen = true
+      end
+
+      def deep_frozen?
+        !!@deep_frozen
+      end
+    end
+
+    # Holds deep_freeze extensions to OpenStruct
+    module OpenStruct
+      def deep_freeze
+        unless deep_frozen?
+          @table.reduce({}) do |h, (key, value)|
+            fkey = key.respond_to?(:deep_freeze) ? key.deep_freeze : key
+            fval = value.respond_to?(:deep_freeze) ? value.deep_freeze : value
+            h.merge(fkey => fval)
+          end.freeze
+          @deep_frozen = true
+        end
+      end
+
+      def deep_frozen?
+        !!@deep_frozen
+      end
+    end
+  end
+
+  # Refines the Hash class with some convenience methods.
+  # Must call `using CemAcpt::CoreExtensions::HashExtensions`
+  # before these methods will be available.
+  module ExtendedHash
+    refine Hash do
+      # Formats a hash by converting all keys to symbols.
+      # If any value is a hash, it will be recursively
+      # extend and formatted.
+      def format!
+        transform_keys!(&:to_sym)
+        transform_values! do |value|
+          if value.is_a?(Hash)
+            value.format!
+          else
+            value
+          end
+        end
+      end
+
+      def has?(path)
+        !!dot_dig(path)
+      end
+
+      # Digs into a Hash using a dot-separated path.
+      # If the path is not found, returns nil.
+      # Example:
+      #   hash = {a: {b: {c: 1}}}
+      #   hash.dot_dig('a.b.c') # => 1
+      def dot_dig(path)
+        dig(*path.split('.').map(&:to_sym)) || dig(*path.split('.'))
+      end
+
+      # Stores a value in a nested Hash using a dot-separated path
+      # to dig through keys.
+      # Example:
+      #   hash = {a: {b: {c: 1}}}
+      #   hash.dot_store('a.b.c', 2)
+      #   hash #=> {a: {b: {c: 2}}}
+      def dot_store(path, value)
+        *key, last = path.split('.').map(&:to_sym)
+        key.inject(self, :fetch)[last] = value
+      end
+    end
+  end
+end

data/lib/cem_acpt/image_name_builder.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module CemAcpt
+  require_relative 'core_extensions'
+  require_relative 'logging'
+
+  # Dynamically builds an image name based on parameters specified in the
+  # config. The config is expected to have a key 'image_name_builder' with
+  # the following options:
+  #   - 'parts'                   - (Required) An array of strings to be joined together to form the image name.
+  #                                   If the strings begin with a '$', they will be replaced with the corresponding
+  #                                   value from current test data. To specify nested keys, use '.' to separate
+  #                                   the keys. Example: '$name.pattern.framework' will be replaced with the
+  #                                   value of the name pattern key framework in the current test data.
+  #   - 'join_with'               - (Optional) The string to join the parts with. Defaults to ''.
+  #   - 'character_substitutions' - (Optional) An array of of 2-item arrays. The first item
+  #                                   is the character to replace, the second is the replacement.
+  #                                   Example: [[' ', '-'], ['_', '-']] will replace all spaces
+  #                                   and underscores with dashes.
+  #   - 'validation_pattern'      - (Optional) A regex pattern to validate the image name against.
+  class ImageNameBuilder
+    include CemAcpt::Logging
+    using CemAcpt::CoreExtensions::ExtendedHash
+
+    # Initializes the ImageNameBuilder.
+    # @param config [CemAcpt::Config] The config to use.
+    def initialize(config)
+      unless config.has?('image_name_builder')
+        raise ArgumentError, 'Configuration does not have an image_name_builder key'
+      end
+
+      @config = config.get('image_name_builder')
+    end
+
+    # Builds an image name based on the config. It does so in three steps:
+    #   1. Resolve variables in the parts array.
+    #   2. Join the parts together with the join_with string if specified
+    #      and validate the image name against the validation_pattern if
+    #      specified.
+    #   3. Perform any specified character substitutions on the image name.
+    # @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
+    end
+
+    private
+
+    # Resolves variables in the parts array by replacing them with the
+    # corresponding value from the test data.
+    # @param test_data [Hash] The test data to use to build the image name.
+    # @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
+        end
+      end
+    end
+
+    # Creates an image name based on the parts array.
+    # @param parts [Array] The parts array to use to build the image name.
+    # @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]}"
+      end
+      image_name
+    end
+
+    # Performs character substitutions on the image name.
+    # @param name [String] The image name to perform substitutions on.
+    # @return [String] The image name with substitutions performed.
+    def character_substitutions(name)
+      return name unless @config[:character_substitutions]
+
+      subbed_name = name
+      @config[:character_substitutions].each do |char_sub|
+        subbed_name.gsub!(char_sub[0], char_sub[1])
+      end
+      subbed_name
+    end
+  end
+end