cem_acpt 0.2.6-universal-java-17

data/lib/cem_acpt/platform/gcp.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# GCP platform implementation
+module Platform
+  require_relative 'gcp/compute'
+  require_relative 'gcp/cmd'
+
+  # Returns information about the GCP instance
+  def node
+    @instance.info
+  end
+
+  # Provision a GCP instance
+  def provision
+    creation_params = config.dup
+    creation_params[:disk][:image_name] = image_name
+    creation_params[:local_port] = local_port
+    @instance = CemAcpt::Platform::Gcp::VM.new(
+      node_name,
+      components: creation_params,
+    )
+    @instance.configure!
+    logger.debug("Creating with command: #{@instance.send(:create_cmd)}")
+    @instance.create
+  end
+
+  # Destroy a GCP instance
+  def destroy
+    @instance.destroy
+  end
+
+  # Returns true if the GCP instance is ready for use in the test suite
+  def ready?
+    logger.debug("Checking if #{node_name} is ready...")
+    @instance.ready?
+  end
+
+  # Runs the test suite against the GCP instance. Must be given a block.
+  # If necessary, can pass information into the block to be used in the test suite.
+  def run_tests(&block)
+    logger.debug("Running tests for #{node_name}...")
+    block.call @instance.cmd.env
+  end
+
+  # Uploads and installs a Puppet module package on the GCP instance.
+  def install_puppet_module_package(module_pkg_path, remote_path = nil, puppet_path = '/opt/puppetlabs/bin/puppet')
+    remote_path = remote_path.nil? ? File.join('/tmp', File.basename(module_pkg_path)) : remote_path
+    logger.info("Uploading module package #{module_pkg_path} to #{remote_path} on #{node_name} and installing it...")
+    logger.debug("Using puppet path: #{puppet_path}")
+    @instance.install_puppet_module_package(module_pkg_path, remote_path, puppet_path)
+    logger.info("Module package #{module_pkg_path} installed on #{node_name}")
+  end
+
+  # Extends the class with class methods from the SpecMethods module
+  def self.included(base)
+    base.extend(SpecMethods)
+  end
+
+  # Holds class methods called from spec tests.
+  module SpecMethods
+    # Returns an instance of the GCP platform class command provider
+    # @return [CemAcpt::Platform::Gcp::Cmd]
+    def command_provider
+      CemAcpt::Platform::Gcp::Cmd.new(out_format: 'json')
+    end
+
+    # Apllies the given Puppet manifest on the given instance
+    # @param instance_name [String] the name of the instance to apply the manifest to
+    # @param manifest [String] the Puppet manifest to apply
+    # @param opts [Hash] options to pass to the apply command
+    # @return [String] the output of the apply command
+    def apply_manifest(instance_name, manifest, opts = {})
+      command_provider.apply_manifest(instance_name, manifest, opts)
+    end
+
+    # Runs a shell command on the given instance
+    # @param instance_name [String] the name of the instance to run the command on
+    # @param command [String] the command to run
+    # @param opts [Hash] options to pass to the run_shell command
+    # @return [String] the output of the run_shell command
+    def run_shell(instance_name, cmd, opts = {})
+      command_provider.run_shell(instance_name, cmd, opts)
+    end
+  end
+end

data/lib/cem_acpt/platform/vmpooler.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Currently a placeholder for future functionality
+module Platform
+  def node
+    logger.debug 'VMPooler node'
+  end
+
+  def provision
+    logger.debug 'VMPooler provision'
+  end
+
+  def destroy
+    logger.debug 'VMPooler destroy'
+  end
+
+  def ready?
+    logger.debug 'VMPooler ready?'
+  end
+
+  def install_puppet_module_package
+    logger.debug 'VMPooler install_puppet_module_package'
+  end
+end

data/lib/cem_acpt/platform.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'concurrent-ruby'
+
+# CemAcpt::Platform manages creating and configring platform specific objects
+# for the acceptance test suites.
+module CemAcpt::Platform
+  require_relative 'logging'
+
+  class Error < StandardError; end
+
+  PLATFORM_DIR = File.expand_path(File.join(__dir__, 'platform'))
+
+  class << self
+    include CemAcpt::Logging
+
+    # Creates a new platform specific object of the given platform for each
+    # item in the test data.
+    # @param platform [String] the name of the platform
+    # @param config [CemAcpt::Config] the config object
+    # @param test_data [Hash] the test data
+    # @param local_port_allocator [CemAcpt::LocalPortAllocator] the local port allocator
+    def use(platform, config, test_data, local_port_allocator)
+      raise Error, "Platform #{platform} is not supported" unless platforms.include?(platform)
+      raise Error, 'test_data must be an Array' unless test_data.is_a?(Array)
+
+      logger.info "Using #{platform} for #{test_data.length} tests..."
+      test_data.each_with_object([]) do |single_test_data, ary|
+        local_port = local_port_allocator.allocate
+        logger.debug("Allocated local port #{local_port} for test #{single_test_data[:test_name]}")
+        ary << new_platform_object(platform, config, single_test_data, local_port)
+      end
+    end
+
+    # Returns an un-initialized platform specific Class of the given platform.
+    # @param platform [String] the name of the platform
+    def get(platform)
+      raise Error, "Platform #{platform} is not supported" unless platforms.include?(platform)
+
+      platform_class(platform)
+    end
+
+    private
+
+    # Dynamically creates a new platform class if it doesn't exist
+    # and returns a new instance of it.
+    # @param platform [String] the name of the platform.
+    # @param config [CemAcpt::Config] the config object.
+    # @param single_test_data [Hash] the test data for a single test.
+    # @return [CemAcpt::Platform::Base] an initialized platform class.
+    def new_platform_object(platform, config, single_test_data, local_port)
+      raise Error, 'single_test_data must be a Hash' unless single_test_data.is_a?(Hash)
+
+      platform_class(platform).new(config, single_test_data, local_port)
+    end
+
+    # Creates a new platform-specific Class object for the given platform.
+    # Does not initialize the class.
+    # @param platform [String] the name of the platform.
+    # @return [Class] the platform-specific Object.
+    def platform_class(platform)
+      # We require the platform base class here so that we can use it as
+      # a parent class for the platform-specific class.
+      require_relative 'platform/base'
+      # If the class has already been defined, we can just use it.
+      if Object.const_defined?(platform.capitalize)
+        klass = Object.const_get(platform.capitalize)
+      else
+        # Otherwise, we need to create the class. We do this by setting
+        # a new constant with the name of the platform capitalized, and
+        # associate that constant with a new instance of Class that inherits
+        # from the platform base class. We then require the platform file,
+        # include and extend our class with the Platform module from the file,
+        # include Logging and Concurrent::Async, and finally call the
+        # initialize method on the class.
+        klass = Object.const_set(
+          platform.capitalize,
+          Class.new(CemAcpt::Platform::Base) do
+            require_relative "platform/#{platform}"
+            include Platform
+          end,
+        )
+      end
+      klass
+    end
+
+    # Returns an array of the names of the supported platforms.
+    # Supported platforms are discovered by looking for files in the
+    # platform directory, and platform names are the basename (no extension)
+    # of the files. We deliberately exclude the base class, as it is not
+    # a platform.
+    def platforms
+      return @platforms if defined?(@platforms)
+
+      @platforms = Dir.glob(File.join(PLATFORM_DIR, '*.rb')).map do |file|
+        File.basename(file, '.rb') unless file.end_with?('base.rb')
+      end
+      @platforms.compact!
+      logger.debug "Discovered platform(s): #{@platforms}"
+      @platforms
+    end
+  end
+end

data/lib/cem_acpt/puppet_helpers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'logging'
+
+module CemAcpt
+  # Holds modules that provide helper methods for various Puppet-related
+  # tasks.
+  module PuppetHelpers
+    # Provides helper methods for Puppet Modules.
+    module Module
+      class << self
+        include CemAcpt::Logging
+      end
+
+      # Builds a Puppet module package.
+      # @param module_dir [String] Path to the module directory. If target_dir
+      #   is specified as a relative path, it will be relative to the module dir.
+      # @param target_dir [String] Path to the target directory where the package
+      #   will be built. This defaults to the relative path 'pkg/'.
+      # @param should_log [Boolean] Whether or not to log the build process.
+      # @return [String] Path to the built package.
+      def self.build_module_package(module_dir, target_dir = nil, should_log: false)
+        require 'puppet/modulebuilder'
+        require 'fileutils'
+
+        builder_logger = should_log ? logger : nil
+        builder = Puppet::Modulebuilder::Builder.new(File.expand_path(module_dir), target_dir, builder_logger)
+
+        # Validates module metadata by raising exception if invalid
+        _metadata = builder.metadata
+        logger.debug("Metadata for module #{builder.release_name} is valid")
+
+        # Builds the module package
+        logger.info("Building module package for #{builder.release_name}")
+        builder.build
+      end
+    end
+  end
+end

data/lib/cem_acpt/rspec_utils.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'open3'
+require 'pty'
+require 'shellwords'
+require_relative 'logging'
+
+module CemAcpt
+  # Module that provides methods and objects for running and managing RSpec
+  module RSpecUtils
+    class BundlerNotFoundError < StandardError; end
+    class RSpecNotFoundError < StandardError; end
+
+    # Holds and formats a RSpec command
+    class Command
+      include CemAcpt::LoggingAsync
+      attr_reader :debug, :format, :test_path, :use_bundler, :pty_pid
+
+      # @param opts [Hash] options hash for the RSpec command
+      # @option opts [String] :test_path The path (or glob path) to the test file(s) to run. If blank, runs all.
+      # @option opts [Hash] :format Format options for rspec where the key is the format (documentation, json, etc)
+      #   and the value is the out-file path. If you do not want to save the results of a format to a file, the
+      #   value should be `nil`.
+      # @option opts [Boolean] :debug True if RSpec should run in debug mode, false if not. Mutually exclusive with
+      #   `:quiet`. Default is `false`.
+      # @option opts [Boolean] :quiet True if no output should be logged from RSpec command, false if output should
+      #   be logged. Mutually exclusive with `:debug`. Default is `false`.
+      # @option opts [Boolean] :use_bundler Whether or not `bundle exec` should be used to run the RSpec command.
+      #   Default is `true`.
+      # @option opts [Boolean] :bundle_install Whether or not to run `bundle install` before the RSpec command
+      #   if `use_bundler` is `true`.
+      # @option opts [Boolean] :use_shell Whether or not to add `$SHELL` as a prefix to the command
+      # @option opts [Hash] :env Environment variables to prepend to the command
+      def initialize(opts = {})
+        @test_path = opts[:test_path]&.shellescape
+        @format = opts.fetch(:format, {})
+        @debug = opts.fetch(:debug, false)
+        @quiet = @debug ? false : opts.fetch(:quiet, false)
+        @use_bundler = opts.fetch(:use_bundler, false)
+        @bundle_install = opts.fetch(:bundle_install, false)
+        @env = opts.fetch(:env, {})
+        @pty_pid = nil
+        validate_and_set_bin_paths(opts)
+      end
+
+      # Sets debug mode to `true`
+      def set_debug
+        @debug = true
+        if @quiet
+          async_debug('Setting :quiet to false because :debug is now true.')
+          @quiet = false
+        end
+      end
+
+      # Sets debug mode to `false`
+      def unset_debug
+        @debug = false
+      end
+
+      def quiet
+        @quiet && !debug
+      end
+
+      # Adds a new format to the RSpec command
+      # @param fmt [String] The name of the format (i.e. "documentation", "json", etc.)
+      # @param out [String] If specified, saves the specified format to a file at this path
+      def with_format(fmt, out: nil)
+        @format[fmt.to_sym] = out
+      end
+
+      # Environment variables that will be used for the RSpec command
+      # @return [Hash] A Hash of environment variables with each key pair being: <var name> => <var value>
+      def env
+        @debug ? @env.merge({ 'RSPEC_DEBUG' => 'true' }) : @env
+      end
+
+      # Returns an array representation of the RSpec command
+      def to_a
+        cmd = cmd_base.dup
+        cmd << test_path if test_path
+        format.each do |fmt, out|
+          cmd += ['--format', fmt.to_s.shellescape]
+          cmd += ['--out', out.to_s.shellescape] if out
+        end
+        cmd.compact
+      end
+
+      # Returns a string representation of the RSpec command
+      def to_s
+        to_a.join(' ')
+      end
+
+      # Executes the RSpec command on the current machine
+      # @param pty [Boolean] If true, execute command in a PTY. If false, execute command directly.
+      # @param log_prefix [String] A prefix to add to log messages generated while the command is running.
+      def execute(pty: true, log_prefix: 'RSPEC')
+        if pty
+          execute_pty(log_prefix: log_prefix)
+        else
+          execute_no_pty(log_prefix: log_prefix)
+        end
+      end
+
+      # Executes the RSpec command in a psuedo-terminal (PTY). First, it spawns a process
+      # for $SHELL, sets environment variables `export_envs`, then calls the current RSpec
+      # command in the shell and exits with the last exit code `$?`. Output is read from the
+      # RSpec command in near real-time in a blocking manner unless the `:quiet` option has
+      # been specified.
+      # @param log_prefix [String] A prefix to add to the log messages that are output from
+      #   the RSpec command.
+      # @return [Integer] The exit code of the RSpec command
+      def execute_pty(log_prefix: 'RSPEC')
+        async_debug("Executing RSpec command '#{self}' in PTY...", log_prefix)
+        PTY.spawn(env, ENV['SHELL']) do |r, w, pid|
+          @pty_pid = pid
+          async_debug("Spawned RSpec PTY with PID #{@pty_pid}", log_prefix)
+          export_envs(w)
+          w.puts "#{self}; exit $?"
+          quiet ? wait_io(r) : read_io(r, log_prefix: log_prefix)
+        end
+        $CHILD_STATUS
+      end
+
+      # Executes the RSpec command using Open3.popen2e(). The output stream, which is both
+      # stderr and stdout, is read in real-time in a non-blocking manner.
+      # @param log_prefix [String] A prefix to add to the log messages that are output from
+      #   the RSpec command.
+      # @return [Integer] The exit code of the RSpec command
+      def execute_no_pty(log_prefix: 'RSPEC')
+        async_info("Executing RSpec command '#{self}' with Open3.popen2e()...", log_prefix)
+        exit_status = nil
+        Open3.popen2e(env, to_s) do |stdin, std_out_err, wait_thr|
+          stdin.close
+          quiet ? wait_io(std_out_err) : read_io(std_out_err, log_prefix: log_prefix)
+          exit_status = wait_thr.value
+        end
+        exit_status
+      end
+
+      # Kills the PTY process with `SIGKILL` if the process exists
+      def kill_pty
+        Process.kill('KILL', @pty_pid) unless @pty_pid.nil?
+      rescue Errno::ESRCH
+        true
+      end
+
+      private
+
+      # Detects if the current Ruby context is JRuby
+      def jruby?
+        File.basename(RbConfig.ruby) == 'jruby'
+      end
+
+      # The base RSpec command
+      def cmd_base
+        use_bundler ? cmd_base_bundler : cmd_base_rspec
+      end
+
+      # The base RSpec command if `:use_bundler` is `true`.
+      def cmd_base_bundler
+        base = [@bundle, 'exec', 'rspec']
+        base.unshift("#{@bundle} install;") if @bundle_install
+        base
+      end
+
+      # The base RSpec command if `:use_bundler` is `false`
+      def cmd_base_rspec
+        [@rspec]
+      end
+
+      # Puts export statements for each key-value pair in `env` to the given writer.
+      # Writer is the write pipe of a PTY session, or a similar IO object that can
+      # pass the statements to a shell.
+      # @param writer [IO] An IO object that supprts `puts` and can send statements to a shell
+      def export_envs(writer)
+        env.each do |key, val|
+          writer.puts "export #{key}=#{val}"
+        end
+      end
+
+      # Finds and sets the paths to the `bundle` and `rspec` binaries. The paths can
+      # be either passed in as options in the `opts` Hash or interrogated from the
+      # system.
+      # @param opts [Hash] The options hash
+      # @option opts [String] :bundle An absolute path on the system to the `bundle` binary.
+      # @option opts [String] :rspec An absolute path on the system to the `rspec` binary.
+      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
+      #   `bundle` binary is not found.
+      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
+      def validate_and_set_bin_paths(opts = {})
+        %i[bundle rspec].each do |bin|
+          bin_path = opts[bin] || `command -v #{bin}`.strip
+          bin_not_found(bin, bin_path) unless bin_path && File.exist?(bin_path)
+          instance_variable_set("@#{bin}", bin_path)
+        end
+      end
+
+      # Handles binary paths which are not found
+      # @param bin [Symbol] The binary that was not found, either :bundle or :rspec.
+      # @param bin_path [String] The path to the binary that was checked.
+      # @raise [CemAcpt::RSpecUtils::BundlerNotFoundError] if `@use_bundler` is true and
+      #   `bundle` binary is not found.
+      # @raise [CemAcpt::RSpecUtils::RSpecNotFoundError] if `rspec` binary is not found.
+      # @raise [RuntimeError] if `bin` is not :bundle or :rspec.
+      def bin_not_found(bin, bin_path)
+        msg_base = "#{bin} not found."
+        msg = bin_path.nil? ? "#{msg_base} Path is nil." : "#{msg_base} Path: #{bin_path}"
+        case bin
+        when :bundle
+          raise BundlerNotFoundError, msg if @use_bundler
+        when :rspec
+          raise RSpecNotFoundError, msg
+        else
+          raise "bin #{bin} not recognized!"
+        end
+      end
+
+      # Blocking wait on an IO stream. Wait stops once the IO stream has reached
+      # end of file.
+      # @param stdout [IO] An IO stream with output that can be read from.
+      def wait_io(stdout)
+        sleep(0.01) until stdout.eof?
+      end
+
+      # Reads and logs data from `stdout` in a near real-time, blocking manner.
+      # @param stdout [IO] An IO stream with output that can be read from.
+      # @param log_prefix [String] A string prefix that is added to log messages.
+      def read_io(stdout, log_prefix: 'RSPEC')
+        loop do
+          chunk = stdout.read_nonblock(4096).strip
+          async_info(chunk, log_prefix) unless chunk.nil? || chunk.empty?
+        rescue IO::WaitReadable
+          IO.select([stdout])
+          retry
+        rescue EOFError
+          break
+        end
+      end
+    end
+  end
+end