cem_acpt 0.2.5 → 0.6.0

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

@@ -1,129 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,12 +0,0 @@
-# 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

@@ -1,153 +0,0 @@
-# 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/platform/base/cmd.rb

@@ -1,71 +0,0 @@
-# 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