cem_acpt 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 853cc9a89c0feaf798bb5efdfc0c8af47d2664121cddd3794b65a61d5dc80851
-  data.tar.gz: 6d0d5c67e27918d7897ea567a4134249c8a81e23ea95e6a3850a65585ebdd3e0
+  metadata.gz: c7329475f3aa0a02e2b6f65017ed0c24b35769f31eddcff07f306297d99b6558
+  data.tar.gz: 346c753606378a5b022f2c0cd5e2f3db37dbc473468828075c1c6b9d1f2bf8d6
 SHA512:
-  metadata.gz: 244c701ba966fa878c399efba4953db7be8f5977c906501f9d2da8410583ebf2c2c505c687dc03e8cd97b325f362b28472f68c089065cda21f83d01d16c15d22
-  data.tar.gz: ae7ca222e4264ed32ed47df2745d76c8347c1b5eab94cd2f0278af581c7c7108fb006232c5bbb4d37b2455559c0826a5630498cd620d4fd85a8948b8a0856c22
+  metadata.gz: d3eeb3af0f675509e0e02f658656a21d66e682c2d127196155a44adedade3513f4361dd78bb818070d0bd4bb2e349782d4a475a3d1a7a51b9ab800bcc0d9b1e6
+  data.tar.gz: 2ac9dc43f0bd592b22053599060ffce68cccb995b32755686c0c4128cf69c2d125b155738be38a0ad91cbca7e7017109ab0721bfda4adaae4da46ab72e30a00d

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cem_acpt (0.8.0)
+    cem_acpt (0.8.1)
       async-http (>= 0.60, < 0.70)
       bcrypt_pbkdf (>= 1.0, < 2.0)
       deep_merge (>= 1.2, < 2.0)

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

@@ -4,6 +4,7 @@ require 'json'
 require 'open3'
 require 'stringio'
 require_relative '../../logging'
+require_relative '../../utils/shell'
 
 module CemAcpt
   module Provision
@@ -81,34 +82,10 @@ module CemAcpt
       end
 
       def run_cmd(cmd, opts = {}, env = {}, suffix: '')
-        logger.debug('CemAcpt::Provision::TerraformCmd') { "Running command with args: cmd = \"#{cmd}\", opts = \"#{opts}\", env = \"#{env}\", suffix = \"#{suffix}\"" }
-        val, outerr = execute(format_cmd(cmd, opts, suffix), environment(env))
-        raise "Error running command: #{cmd}\n#{outerr}" unless val.success?
-
-        outerr
-      end
-
-      def execute(cmd, env)
-        logger.debug('CemAcpt::Provision::TerraformCmd') { "Executing command: #{cmd}" }
-        io_outerr = StringIO.new
-        val = Open3.popen2e(env, cmd) do |stdin, outerr, wait_thr|
-          stdin.close
-          outerr.sync = true
-          output_thread = Thread.new do
-            while (line = outerr.readline_nonblock)
-              logger << line
-              io_outerr.write(line) unless line.chomp.empty?
-            end
-          rescue IO::WaitReadable
-            retry
-          rescue EOFError
-            # Do nothing
-          end
-          wait_thr.join
-          output_thread.exit
-          wait_thr.value
-        end
-        [val, io_outerr.string]
+        cmd = format_cmd(cmd, opts, suffix)
+        env = environment(env)
+        logger.debug('CemAcpt::Provision::TerraformCmd') { "Running command \"#{cmd}\" with environment \"#{env}\"" }
+        CemAcpt::Utils::Shell.run_cmd(cmd, env, output: logger)
       end
 
       def chdir(opts = {})
@@ -123,14 +100,10 @@ module CemAcpt
       end
 
       def which_terraform
-        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-          exts.each do |ext|
-            exe = File.join(path, "terraform#{ext}")
-            return exe if File.executable?(exe) && !File.directory?(exe)
-          end
-        end
-        raise 'terraform not found in PATH, make sure it is installed'
+        path = CemAcpt::Utils::Shell.which('terraform')
+        raise 'terraform not found in PATH, make sure it is installed' if path.nil?
+
+        path
       end
 
       def format_cmd(cmd, opts = {}, suffix = '')

data/lib/cem_acpt/provision/terraform.rb

@@ -36,7 +36,13 @@ module CemAcpt
         terraform_init
         terraform_plan(formatted_vars, DEFAULT_PLAN_NAME)
         terraform_apply(DEFAULT_PLAN_NAME)
-        JSON.parse(terraform_output('instance_name_ip', json: true))
+        begin
+          output = terraform_output('instance_name_ip', json: true)
+          JSON.parse(output)
+        rescue JSON::ParserError => e
+          logger.error('CemAcpt::Provision::Terraform') { "Error parsing Terraform output: #{output}" }
+          raise e
+        end
       end
 
       def destroy

data/lib/cem_acpt/test_runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'securerandom'
 require_relative 'action_result'
 require_relative 'goss'
@@ -8,7 +9,6 @@ require_relative 'platform'
 require_relative 'provision'
 require_relative 'test_data'
 require_relative 'utils'
-require_relative 'utils/winrm_runner'
 require_relative 'version'
 require_relative 'test_runner/log_formatter'
 
@@ -30,6 +30,7 @@ module CemAcpt
         @results = []
         @http_statuses = []
         @provisioned = false
+        @destroyed = false
       end
 
       def inspect
@@ -48,7 +49,6 @@ module CemAcpt
         Dir.chdir(module_dir)
         logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run started at #{@start_time}")
         logger.info('CemAcpt::TestRunner') { "Using module directory: #{module_dir}..." }
-        keep_terminal_alive
         @run_data[:private_key], @run_data[:public_key], @run_data[:known_hosts] = new_ephemeral_ssh_keys
         logger.info('CemAcpt::TestRunner') { 'Created ephemeral SSH key pair...' }
         @run_data[:module_package_path] = build_module_package
@@ -74,7 +74,7 @@ module CemAcpt
             # instance_names_ips. It contains the username, password, and ip of the
             # windows node, as well as the test name that will be run on that node.
             login_info = CemAcpt::Utils.get_windows_login_info(k, v)
-            win_node = CemAcpt::Utils::WinRMRunner::WinNode.new(login_info, @run_data[:module_package_path].split('/').last)
+            win_node = CemAcpt::Utils::WinRMRunner::WinNode.new(login_info, @run_data[:win_remote_module_name])
             win_node.run
           end
         end
@@ -85,43 +85,37 @@ module CemAcpt
         logger.error('CemAcpt::TestRunner') { 'Run failed due to error...' }
         @results << ActionResult.new(e)
       ensure
+        logger.end_ci_group
         clean_up
         process_test_results
         Dir.chdir(@old_dir) if @old_dir
         @results
       end
 
-      def clean_up(trap_context = false)
-        logger.end_ci_group
-        kill_keep_terminal_alive unless trap_context
-        cleanup_bucket # Clean up bucket if we're testing the cem_windows module
-
-        return no_destroy if config.get('no_destroy_nodes')
+      def clean_up(_trap_context = false)
+        logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run finished at #{Time.now}")
+        logger.debug('CemAcpt::TestRunner') { "Starting clean up, provisioned: #{@provisioned}, destroyed: #{@destroyed}" }
 
-        clean_ephemeral_ssh_keys
-        destroy_test_nodes if @provisioned && !@destroyed
+        if config.get('no_destroy_nodes')
+          logger.warn('CemAcpt::TestRunner') { 'Not destroying test nodes because no-destroy-nodes is set...' }
+          @provisioner&.show
+          logger.info('CemAcpt') { "Test SSH Keys:\n  Private Key: #{@run_data[:private_key]}\n  Public Key:#{@run_data[:public_key]}" }
+        else
+          cleanup_bucket # Clean up bucket if we're testing the cem_windows module
+          clean_ephemeral_ssh_keys
+          destroy_test_nodes
+        end
       rescue StandardError => e
         logger.verbose('CemAcpt::TestRunner') { "Error cleaning up: #{e}" }
         logger.verbose('CemAcpt::TestRunner') { e.backtrace.join("\n") }
+      ensure
+        logger.end_ci_group
       end
 
       private
 
       attr_reader :config
 
-      # @return [Thread] The thread that keeps the terminal alive
-      def keep_terminal_alive
-        return unless config.ci?
-
-        @keep_terminal_alive ||= CemAcpt::Utils::Terminal.keep_terminal_alive
-      end
-
-      def kill_keep_terminal_alive
-        return if @trap_context
-
-        keep_terminal_alive&.kill
-      end
-
       # @return [String] The path to the module package
       def build_module_package
         if config.get('tests').first.include? 'windows'
@@ -163,23 +157,22 @@ module CemAcpt
       end
 
       def destroy_test_nodes
-        return no_destroy if config.get('no_destroy_nodes')
-
-        logger.info('CemAcpt::TestRunner') { 'Destroying test nodes...' }
-        logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run finished at #{Time.now}")
-        @provisioner&.destroy
-        @destroyed = true
-      ensure
-        logger.end_ci_group
+        logger.info('CemAcpt::TestRunner') { 'Destroying test nodes if necessary...' }
+        if !@provisioned
+          logger.warn('CemAcpt::TestRunner') { 'Test nodes not provisioned, nothing to destroy...' }
+        elsif @destroyed
+          logger.warn('CemAcpt::TestRunner') { 'Test nodes already destroyed, not destroying...' }
+        else
+          logger.info('CemAcpt::TestRunner') { 'Test nodes are provisioned and not destroyed, destroying...' }
+          @provisioner&.destroy
+          @destroyed = true
+        end
       end
 
       def no_destroy
-        logger.warn('CemAcpt::TestRunner') { 'Not destroying test nodes...' }
-        logger.start_ci_group("CemAcpt v#{CemAcpt::VERSION} run finished at #{Time.now}")
+        logger.warn('CemAcpt::TestRunner') { 'Not destroying test nodes because no-destroy-nodes is set...' }
         @provisioner&.show
         logger.info('CemAcpt') { "Test SSH Keys:\n  Private Key: #{@run_data[:private_key]}\n  Public Key:#{@run_data[:public_key]}" }
-      ensure
-        logger.end_ci_group
       end
 
       def run_tests(hosts, only_actions, except_actions)
@@ -248,38 +241,25 @@ module CemAcpt
       # This should only be done once per cem_acpt run. It's important to update the module_package_path
       # in the run_data to reflect the new module path if we do end up changing the module name
       def upload_module_to_bucket
-        curr_module_path = @run_data[:module_package_path].split('/')[0..-2].join('/')
-        curr_module_name = @run_data[:module_package_path].split('/')[-1]
-
-        logger.debug('CemAcpt') { 'Checking if there duplicate cem_windows module in the bucket already...' }
-        # Checking if the module already exists in the bucket. Gcloud will return an empty string if the module
-        # doesn't exist in the bucket.
-        attempts = 0
-        until `gcloud storage ls gs://win_cem_acpt/#{curr_module_name}`.empty? do
-          raise "Failed to rename duplicate module in GCloud" if attempts >= 3
-
-          logger.debug('CemAcpt') { 'Duplicate cem_windows module found. Renaming cem_windows module...' }
-          # Rename the cem_windows module
-          curr_module_name = SecureRandom.uuid << curr_module_name
-          `mv #{@run_data[:module_package_path]} #{curr_module_path}/#{curr_module_name}`
-          # update the module_package_path in the run_data
-          @run_data[:module_package_path] = File.join(curr_module_path, curr_module_name)
-          attempts += 1
-        end
+        @run_data[:win_remote_module_name] = SecureRandom.uuid << File.split(@run_data[:module_package_path]).last
+        @run_data[:win_remote_module_path] = File.join('gs://win_cem_acpt', @run_data[:win_remote_module_name])
         # Upload the module from the local host to the bucket
-        logger.info('CemAcpt') { 'Transporting cem_windows module...' }
-        gcloud_cmd = `gcloud storage cp #{@run_data[:module_package_path]} gs://win_cem_acpt`
-        logger.debug('CemAcpt') { "Uploaded cem_windows module to bucket: #{gcloud_cmd}" }
+        logger.info('CemAcpt') { "Uploading #{@run_data[:module_pakage_path]} to #{@run_data[:win_remote_module_path]}..." }
+        CemAcpt::Utils::Shell.run_cmd("gcloud storage cp #{@run_data[:module_package_path]} #{@run_data[:win_remote_module_path]}")
+        logger.debug('CemAcpt') { 'Successfully uploaded module' }
       end
 
       # We have to clean up our gcp bucket after we're done testing. This will limit the duplicated
       # modules existing in the bucket.
       def cleanup_bucket
-        # Cleanup the module from the bucket
-        cleanup_cmd = `gcloud storage rm gs://win_cem_acpt/#{@run_data[:module_package_path].split('/')[-1]}`
-        logger.debug('CemAcpt') { "Removed module from bucket: #{cleanup_cmd}" }
-      rescue StandardError
-        logger.info('CemAcpt') { 'No module to clean up in the bucket. You might not be running test for cem_windows' }
+        if @run_data[:win_remote_module_path]
+          logger.info('CemAcpt::TestRunner') { "Cleaning up bucket #{@run_data[:win_remote_module_path]}..." }
+          # Cleanup the module from the bucket
+          cleanup_cmd = CemAcpt::Utils::Shell.run_cmd("gcloud storage rm #{@run_data[:win_remote_module_path]}", raise_on_error: false)
+          logger.debug('CemAcpt::TestRunner') { "Removed module from bucket: #{cleanup_cmd}" } unless cleanup_cmd.nil? || cleanup_cmd.empty?
+        else
+          logger.info('CemAcpt::TestRunner') { 'No module to clean up in bucket...' }
+        end
       end
     end
   end

data/lib/cem_acpt/utils/shell.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'stringio'
+
+module CemAcpt
+  # Error class for shell commands
+  class ShellCommandError < StandardError; end
+
+  module Utils
+    # Generic utilities for running local shell commands
+    module Shell
+      # Runs a command in a subshell and returns the Process::Status
+      # and the string output of the command.
+      # @param cmd [String] The command to run
+      # @param env [Hash] A hash of environment variables to set
+      # @param output [IO] An IO object that implements #:<< to write the output of the
+      #   command to in real time. Typically this is a Logger object. Defaults to $stdout.
+      #   If the object responds to #:debug, the command will be logged at the debug level.
+      # @param raise_on_fail [Boolean] Whether to raise an error if the command fails
+      # @return [String] The string output of the command
+      def self.run_cmd(cmd, env = {}, output: $stdout, raise_on_fail: true)
+        io_outerr = StringIO.new
+        if output.respond_to?(:debug)
+          output.debug('CemAcpt::Utils::Shell') { "Running command:\n\t#{cmd}\nWith environment:\n\t#{env}" }
+        else
+          output << "Running command:\n\t#{cmd}\nWith environment:\n\t#{env}\n"
+        end
+        val = Open3.popen2e(env, cmd) do |stdin, outerr, wait_thr|
+          stdin.close
+          outerr.sync = true
+          output_thread = Thread.new do
+            while (line = outerr.readline_nonblock)
+              output << line if output
+              io_outerr.write(line) unless line.chomp.empty?
+            end
+          rescue IO::WaitReadable
+            begin
+              IO.select([outerr])
+              retry
+            rescue IOError
+              # outerr closed, won't retry
+            end
+          rescue EOFError
+            # outerr closed, won't retry
+          end
+          wait_thr.join
+          output_thread.exit
+          wait_thr.value
+        end
+        io_string = io_outerr.string
+        raise CemAcpt::ShellCommandError, "Error running command: #{cmd}\n#{io_string}" if raise_on_fail && !val.success?
+
+        io_string
+      end
+
+      # Mimics the behavior of the `which` command.
+      # @param cmd [String] The command to find
+      # @return [String] The path to the command
+      # @return [nil] If the command is not found
+      def self.which(cmd)
+        return cmd if File.executable?(cmd) && !File.directory?(cmd)
+
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          end
+        end
+        nil
+      end
+
+      # IO monkey patch for non-blocking readline
+      class ::IO
+        def readline_nonblock
+          rlnb = []
+          rnlb << read_nonblock(1) while rlnb[-1] != "\n"
+          rlnb.join
+        rescue IO::WaitReadable => blocking
+          raise blocking if rlnb.empty?
+
+          rlnb.join
+        rescue EOFError
+          rlnb.join
+        end
+      end
+    end
+  end
+end

data/lib/cem_acpt/utils/ssh.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'open3'
+require_relative 'shell'
 require_relative '../logging'
 
 module CemAcpt
@@ -32,9 +32,7 @@ module CemAcpt
           delete(key_name) # Delete existing keys with same name
           cmd = new_keygen_cmd(key_name, **options)
           logger.debug('CemAcpt::Utils::SSH::Keygen') { "Creating SSH key with command: #{cmd}" }
-          _stdout, stderr, status = Open3.capture3(cmd)
-          raise "Failed to create SSH key! #{stderr}" unless status.success?
-
+          CemAcpt::Utils::Shell.run_cmd(cmd, output: logger)
           key_paths(key_name)
         end
 
@@ -53,20 +51,11 @@ module CemAcpt
 
         private
 
-        FIND_BIN_PATH_COMMANDS = [
-          "#{ENV['SHELL']} -c 'command -v ssh-keygen'",
-          "#{ENV['SHELL']} -c 'which ssh-keygen'",
-        ].freeze
-
-        def find_bin_path(find_cmd = FIND_BIN_PATH_COMMANDS.first)
-          bin_path, stderr, status = Open3.capture3(find_cmd)
-          raise "Cannot find ssh-keygen with command #{find_cmd}: #{stderr}" unless status.success?
-
-          bin_path.chomp
-        rescue StandardError => e
-          return find_bin_path(FIND_BIN_PATH_COMMANDS.last) unless FIND_BIN_PATH_COMMANDS.last == find_cmd
+        def find_bin_path
+          bin_path = CemAcpt::Utils::Shell.which('ssh-keygen')
+          raise 'Cannot find command ssh-keygen in PATH, make sure it is installed' if bin_path.nil?
 
-          raise e
+          bin_path
         end
 
         def new_keygen_cmd(key_name, **options)
@@ -100,12 +89,10 @@ module CemAcpt
       end
 
       def self.ssh_keygen
-        bin_path = `#{ENV['SHELL']} -c 'command -v ssh-keygen'`.chomp
-        raise 'Cannot find ssh-keygen! Install it and verify PATH' unless bin_path
+        bin_path = CemAcpt::Utils::Shell.which('ssh-keygen')
+        raise 'Cannot find command ssh-keygen in PATH, make sure it is installed' if bin_path.nil?
 
         bin_path
-      rescue StandardError => e
-        raise "Cannot find ssh-keygen! Install it and verify PATH. Orignal error: #{e}"
       end
 
       def self.default_keydir

data/lib/cem_acpt/utils.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative 'utils/puppet'
+require_relative 'utils/shell'
 require_relative 'utils/ssh'
 require_relative 'utils/terminal'
+require_relative 'utils/winrm_runner'
 require_relative 'logging'
 
 module CemAcpt
@@ -19,17 +21,33 @@ module CemAcpt
         FileUtils.rm_f(package_file)
         `cd #{module_dir} && touch puppetlabs-cem_windows.tar.gz && tar -czf puppetlabs-cem_windows.tar.gz --exclude=puppetlabs-cem_windows.tar.gz *`
         logger.info('CemAcpt') { "Windows module packaged at #{package_file}" }
-        return package_file
+        package_file
       end
 
       def reset_password_readiness_polling(instance_name)
-        result = %x(echo Y | gcloud compute reset-windows-password #{instance_name} --zone=us-west1-b)
-        while result.empty?
+        attempts = 0
+        last_error = nil
+        result = nil
+        begin
+          result = CemAcpt::Utils::Shell.run_cmd("echo Y | gcloud compute reset-windows-password #{instance_name} --zone=us-west1-b")
+        rescue StandardError => e
+          logger.debug('CemAcpt::Utils') { "Error polling for password readiness: #{e}" }
+          last_error = e
+        end
+        while result.nil? || result.empty?
+          raise "Instance not ready for password reset. Last error: #{last_error}" if attempts >= 60 # 10 minutes
+
           logger.info('CemAcpt') { "Waiting for instance #{instance_name} to be ready for password reset..." }
           sleep 10
-          result = %x(echo Y | gcloud compute reset-windows-password #{instance_name} --zone=us-west1-b)
+          begin
+            result = CemAcpt::Utils::Shell.run_cmd("echo Y | gcloud compute reset-windows-password #{instance_name} --zone=us-west1-b")
+          rescue StandardError => e
+            logger.debug('CemAcpt::Utils') { "Error polling for password readiness: #{e}" }
+            last_error = e
+          end
+          attempts += 1
         end
-        return result
+        result
       end
 
       def get_windows_login_info(instance_name, hash_of_instance)

data/lib/cem_acpt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CemAcpt
-  VERSION = '0.8.0'
+  VERSION = '0.8.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cem_acpt
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors:
 - puppetlabs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-30 00:00:00.000000000 Z
+date: 2023-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -237,6 +237,7 @@ files:
 - lib/cem_acpt/test_runner/log_formatter/goss_action_response.rb
 - lib/cem_acpt/utils.rb
 - lib/cem_acpt/utils/puppet.rb
+- lib/cem_acpt/utils/shell.rb
 - lib/cem_acpt/utils/ssh.rb
 - lib/cem_acpt/utils/terminal.rb
 - lib/cem_acpt/utils/winrm_runner.rb