cem_acpt 0.2.5 → 0.6.0

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

data/lib/cem_acpt/platform/gcp.rb

@@ -1,85 +1,71 @@
 # frozen_string_literal: true
 
+require 'json'
+
 # GCP platform implementation
 module Platform
-  require_relative 'gcp/compute'
-  require_relative 'gcp/cmd'
+  def platform_data
+    {
+      username: gcp_username,
+      credentials_file: gcp_credentials_file,
+      project: gcp_project,
+      region: gcp_region,
+      zone: gcp_zone,
+      subnetwork: gcp_subnetwork,
+      private_key: gcp_private_key,
+      public_key: gcp_public_key,
+    }
+  end
 
-  # Returns information about the GCP instance
-  def node
-    @instance.info
+  def node_data
+    {
+      machine_type: gcp_machine_type,
+      image: image_name,
+      disk_size: gcp_disk_size,
+      test_name: @test_data[:test_name],
+    }
   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
+  def gcp_username
+    return @gcp_username if @gcp_username
+
+    @gcp_username = @config.get('platform.username')
+    @gcp_username ||= JSON.parse(`gcloud compute os-login describe-profile --format json`.chomp)['posixAccounts'].first['username']
   end
 
-  # Destroy a GCP instance
-  def destroy
-    @instance.destroy
+  def gcp_credentials_file
+    @gcp_credentials_file ||= (@config.get('platform.credentials_file') || File.join(Dir.home, '.config', 'gcloud', 'application_default_credentials.json'))
   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?
+  def gcp_project
+    @gcp_project ||= (@config.get('platform.project') || `gcloud config get-value project`.chomp)
   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
+  def gcp_region
+    @gcp_region ||= (@config.get('platform.region') || `gcloud config get-value compute/region`.chomp)
   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}")
+  def gcp_zone
+    @gcp_zone ||= (@config.get('platform.zone') || `gcloud config get-value compute/zone`.chomp)
   end
 
-  # Extends the class with class methods from the SpecMethods module
-  def self.included(base)
-    base.extend(SpecMethods)
+  def gcp_subnetwork
+    @gcp_subnetwork ||= (@config.get('platform.subnetwork') || 'default')
   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
+  def gcp_private_key
+    @gcp_private_key ||= (@test_data[:private_key] || File.join(Dir.home, '.ssh', 'google_compute_engine'))
+  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
+  def gcp_public_key
+    @gcp_public_key ||= (@test_data[:public_key] || File.join(Dir.home, '.ssh', 'google_compute_engine.pub'))
+  end
+
+  def gcp_machine_type
+    @gcp_machine_type ||= (@config.get('node_data.machine_type') || 'e2-small')
+  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
+  def gcp_disk_size
+    @gcp_disk_size ||= (@config.get('node_data.disk_size') || 40)
   end
 end

data/lib/cem_acpt/platform.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 require 'concurrent-ruby'
+require_relative 'logging'
 
 # 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'))
@@ -19,16 +18,15 @@ module CemAcpt::Platform
     # @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)
+    def use(platform, config, test_data)
       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)
+        #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)
       end
     end
 
@@ -40,6 +38,22 @@ module CemAcpt::Platform
       platform_class(platform)
     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
+
     private
 
     # Dynamically creates a new platform class if it doesn't exist
@@ -48,10 +62,10 @@ module CemAcpt::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)
+    def new_platform_object(platform, config, single_test_data)
       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)
+      platform_class(platform).new(config, single_test_data)
     end
 
     # Creates a new platform-specific Class object for the given platform.
@@ -59,12 +73,14 @@ module CemAcpt::Platform
     # @param platform [String] the name of the platform.
     # @return [Class] the platform-specific Object.
     def platform_class(platform)
+      class_name = platform.capitalize
       # 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)
+      if Object.const_defined?(class_name)
+        logger.debug "Using existing platform class #{class_name}"
+        klass = Object.const_get(class_name)
       else
         # Otherwise, we need to create the class. We do this by setting
         # a new constant with the name of the platform capitalized, and
@@ -73,31 +89,17 @@ module CemAcpt::Platform
         # 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.
+        logger.debug "Creating platform class #{class_name}"
         klass = Object.const_set(
-          platform.capitalize,
+          class_name,
           Class.new(CemAcpt::Platform::Base) do
             require_relative "platform/#{platform}"
             include Platform
           end,
         )
       end
+      logger.debug "Using platform class: #{klass.inspect}"
       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/provision/terraform/linux.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'os_data'
+
+module CemAcpt
+  module Provision
+    # Class provides methods for gathering provision data for Linux nodes
+    class Linux < OsData
+      def self.valid_names
+        %w[centos rhel oel alma]
+      end
+
+      def self.valid_versions
+        %w[7, 8]
+      end
+
+      def systemd_files
+        Dir.glob(File.join(provision_directory, 'systemd', '*.service')).map { |f| File.basename(f) }
+      end
+
+      def puppet_bin_path
+        '/opt/puppetlabs/puppet/bin/puppet'
+      end
+
+      def destination_provision_directory
+        '/opt/cem_acpt'
+      end
+
+      def provision_commands
+        commands = [
+          "sudo /opt/puppetlabs/puppet/bin/puppet module install #{destination_provision_directory}/#{remote_module_package_name}",
+          'curl -fsSL https://goss.rocks/install | sudo sh',
+        ]
+        unless systemd_files.empty?
+          systemd_files.each do |file|
+            commands << "sudo cp /opt/cem_acpt/systemd/#{file} /etc/systemd/system/#{file}"
+          end
+          commands << 'sudo systemctl daemon-reload'
+          systemd_files.each do |file|
+            commands << "sudo systemctl start #{file} && sudo systemctl enable #{file}"
+          end
+        end
+        commands << "sudo #{puppet_bin_path} apply #{destination_provision_directory}/#{puppet_manifest_file}"
+      end
+    end
+  end
+end

data/lib/cem_acpt/provision/terraform/os_data.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../../logging'
+
+module CemAcpt
+  module Provision
+    # Base class for OS-specific provisioning data
+    class OsData
+      include CemAcpt::Logging
+      extend CemAcpt::Logging
+
+      def self.use_for?(test_name)
+        name_ver = test_name.match(%r{^\w+_(\w+)-(\d+).*})
+        return false unless name_ver && name_ver.length == 3
+
+        if valid_versions.include?(name_ver[2]) || valid_versions.include?(name_ver[2].to_s)
+          return true if valid_names.include?(name_ver[1])
+        end
+
+        false
+      end
+
+      def self.valid_names
+        raise NotImplementedError
+      end
+
+      def self.valid_versions
+        raise NotImplementedError
+      end
+
+      attr_accessor :base_provision_directory
+
+      def initialize(config, provision_data)
+        @config = config
+        @provision_data = provision_data
+        @base_provision_directory = @config.get('terraform.dir')
+      end
+
+      def puppet_bin_path
+        raise NotImplementedError
+      end
+
+      def puppet_manifest_file
+        'manifest.pp'
+      end
+
+      def remote_module_package_name
+        'puppet-module.tar.gz'
+      end
+
+      def implementation_name
+        self.class.to_s.downcase.split('::').last
+      end
+
+      def provision_directory
+        File.join(base_provision_directory, implementation_name)
+      end
+
+      def destination_provision_directory
+        raise NotImplementedError
+      end
+
+      def provision_commands
+        raise NotImplementedError
+      end
+
+      def goss_files
+        Dir.glob(File.join(provision_directory, 'goss', '*.yaml')).map { |f| File.basename(f) }
+      end
+    end
+  end
+end

data/lib/cem_acpt/provision/terraform/windows.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'os_data'
+
+module CemAcpt
+  module Provision
+    # Class provides methods for gathering provision data for Windows nodes
+    class Windows < OsData
+      def self.valid_names
+        %w[windows]
+      end
+
+      def self.valid_versions
+        %w[2016 2019 2022]
+      end
+
+      def puppet_bin_path
+        'C:/Program Files/Puppet Labs/Puppet/bin/puppet.bat'
+      end
+    end
+  end
+end