beaker 4.24.0 → 4.28.0

data/lib/beaker/host/unix/pkg.rb

@@ -5,6 +5,7 @@ module Unix::Pkg
   # unix-specific package management setup
   def pkg_initialize
     @apt_needs_update = true
+    @pacman_needs_update = true
   end
 
   def check_for_command(name)
@@ -71,6 +72,17 @@ module Unix::Pkg
     end
   end
 
+  # Arch Linux is a rolling release distribution. We need to ensure that it is up2date
+  # Except for the kernel. An upgrade will purge the modules for the currently running kernel
+  def update_pacman_if_needed
+    if self['platform'] =~ /archlinux/
+      if @pacman_needs_update
+        execute("pacman --sync --noconfirm --noprogressbar --refresh --sysupgrade --ignore linux --ignore linux-docs --ignore linux-headers")
+        @pacman_needs_update = false
+      end
+    end
+  end
+
   def install_package(name, cmdline_args = '', version = nil, opts = {})
     case self['platform']
       when /sles-/
@@ -138,6 +150,7 @@ module Unix::Pkg
           retry
         end
       when /archlinux/
+        update_pacman_if_needed
         execute("pacman -S --noconfirm #{cmdline_args} #{name}", opts)
       else
         raise "Package #{name} cannot be installed on #{self}"

data/lib/beaker/local_connection.rb

@@ -0,0 +1,86 @@
+require 'open3'
+
+module Beaker
+  class LocalConnection
+
+    attr_accessor :logger, :hostname, :ip
+
+    def initialize options = {}
+      @logger = options[:logger]
+      @ssh_env_file = File.expand_path(options[:ssh_env_file])
+      @hostname = 'localhost'
+      @ip = '127.0.0.1'
+      @options = options
+    end
+
+    def self.connect options = {}
+      connection = new options
+      connection.connect
+      connection
+    end
+
+    def connect options = {}
+      @logger.debug "Local connection, no connection to start"
+    end
+
+    def close
+      @logger.debug "Local connection, no connection to close"
+    end
+
+    def with_env(env)
+      backup = ENV.to_hash
+      ENV.replace(env)
+      yield
+    ensure
+      ENV.replace(backup)
+    end
+
+    def execute command, options = {}, stdout_callback = nil, stderr_callback = stdout_callback
+      result = Result.new(@hostname, command)
+      envs = {}
+      if File.readable?(@ssh_env_file)
+        File.foreach(@ssh_env_file) do |line|
+          key, value = line.split('=')
+          envs[key] = value
+        end
+      end
+
+      begin
+        clean_env = ENV.reject{ |k| k =~ /^BUNDLE|^RUBY|^GEM/ }
+
+        with_env(clean_env) do
+          std_out, std_err, status = Open3.capture3(envs, command)
+          result.stdout << std_out
+          result.stderr << std_err
+          result.exit_code = status.exitstatus
+        end
+      rescue => e
+        result.stderr << e.inspect
+        result.exit_code = 1
+      end
+
+      result.finalize!
+      @logger.last_result = result
+      result
+    end
+
+    def scp_to(source, target, _options = {})
+
+      result = Result.new(@hostname, [source, target])
+      begin
+        FileUtils.cp_r source, target
+      rescue Errno::ENOENT => e
+        @logger.warn "#{e.class} error in cp'ing. Forcing the connection to close, which should " \
+                        "raise an error."
+      end
+
+      result.stdout << "  CP'ed file #{source} to #{target}"
+      result.exit_code = 0
+      result
+    end
+
+    def scp_from(source, target, options = {})
+      scp_to(target, source, options)
+    end
+  end
+end

data/lib/beaker/ssh_connection.rb

@@ -69,8 +69,13 @@ module Beaker
       begin
          @logger.debug "Attempting ssh connection to #{host}, user: #{user}, opts: #{ssh_opts}"
 
+         # Work around net-ssh 6+ incompatibilities
          if ssh_opts.include?(:strict_host_key_checking) && (Net::SSH::Version::CURRENT.major > 5)
-           ssh_opts[:paranoid] = ssh_opts.delete(:strict_host_key_checking)
+           strict_host_key_checking = ssh_opts.delete(:strict_host_key_checking)
+
+           unless ssh_opts[:verify_host_key].is_a?(Symbol)
+             ssh_opts[:verify_host_key] ||= strict_host_key_checking ? :always : :never
+           end
          end
 
          Net::SSH.start(host, user, ssh_opts)

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '4.24.0'
+    STRING = '4.28.0'
   end
 end

data/spec/beaker/host/pswindows/exec_spec.rb

@@ -29,8 +29,8 @@ module Beaker
       it "deletes" do
         path = '/path/to/delete'
         corrected_path = '\\path\\to\\delete'
-        expect( instance ).to receive(:execute).with("del /s /q #{corrected_path}").and_return(0)
-        expect( instance.rm_rf(path) ).to be === 0
+        expect(instance).to receive(:execute).with(%(del /s /q "#{corrected_path}")).and_return(0)
+        expect(instance.rm_rf(path)).to eq(0)
       end
     end
 
@@ -39,10 +39,9 @@ module Beaker
       let(:destination) { '/destination/path/of/content' }
 
       it 'rm first' do
-        expect( instance ).to receive(:execute).with("del /s /q #{destination.gsub(/\//, '\\')}").and_return(0)
-        expect( instance ).to receive(:execute).with("move /y #{origin.gsub(/\//, '\\')} #{destination.gsub(/\//, '\\')}").and_return(0)
-        expect( instance.mv(origin, destination) ).to be === 0
-
+        expect(instance).to receive(:execute).with("del /s /q \"\\destination\\path\\of\\content\"").and_return(0)
+        expect(instance).to receive(:execute).with("move /y #{origin.gsub(/\//, '\\')} #{destination.gsub(/\//, '\\')}").and_return(0)
+        expect(instance.mv(origin, destination)).to eq(0)
       end
 
       it 'does not rm' do

data/spec/beaker/host/unix/exec_spec.rb

@@ -169,6 +169,64 @@ module Beaker
     end
 
     describe '#reboot' do
+      check_cmd_output = {
+        :centos6 => {
+          :who => {
+            :initial => '      system boot  2020-05-13 03:51',
+            :success => '      system boot  2020-05-13 03:52',
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  2.6.32-754.29.1. Tue May 5 17:34:52 2020 - Tue May 5 17:52:48 2020  (00:17)
+              reboot   system boot  2.6.32-754.29.1. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  2.6.32-754.29.1. Tue May 5 17:52:48 2020 - Tue May 5 17:52:49 2020  (00:17)
+              reboot   system boot  2.6.32-754.29.1. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+          },
+        },
+        :centos7 => {
+          :who => {
+            :initial => '      system boot  2020-05-13 03:51',
+            :success => '      system boot  2020-05-13 03:52',
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  3.10.0-1127.el7. Tue May 5 17:34:52 2020 - Tue May 5 17:52:48 2020  (00:17)
+              reboot   system boot  3.10.0-1127.el7. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  3.10.0-1127.el7. Tue May 5 17:52:48 2020 - Tue May 5 17:52:49 2020  (00:17)
+              reboot   system boot  3.10.0-1127.el7. Mon May 4 18:45:43 2020 - Mon May 5 05:35:44 2020 (4+01:50)
+              LAST_F
+          },
+        },
+        :centos8 => {
+          :who => {
+            :initial => '      system boot  2020-05-13 03:51',
+            :success => '      system boot  2020-05-13 03:52',
+          },
+          :last => {
+              :initial => <<~LAST_F,
+              reboot   system boot  4.18.0-147.8.1.e Tue May 5 17:34:52 2020 still running
+              reboot   system boot  4.18.0-147.8.1.e Mon May 4 17:41:27 2020 - Tue May 5 17:00:00 2020 (5+00:11)
+              LAST_F
+              :success => <<~LAST_F,
+              reboot   system boot  4.18.0-147.8.1.e Tue May 5 17:34:53 2020 still running
+              reboot   system boot  4.18.0-147.8.1.e Mon May 4 17:41:27 2020 - Tue May 5 17:00:00 2020 (5+00:11)
+              LAST_F
+          },
+        },
+        :freebsd => {
+          # last -F doesn't work on freebsd so no output will be returned
+          :who => {
+            :initial => '      system boot  May 13 03:51',
+            :success => '      system boot  May 13 03:52',
+          }
+        },
+      }
+
       # no-op response
       let (:response) { double( 'response' ) }
       let (:boot_time_initial_response) { double( 'response' ) }
@@ -179,7 +237,7 @@ module Beaker
       before :each do
         # stubs enough to survive the first boot_time call & output parsing
         #   note: just stubs input-chain between calls, parsing methods still run
-        allow(Beaker::Command).to receive(:new).with('who -b').and_return(:boot_time_command_stub)
+        allow(Beaker::Command).to receive(:new).with('last -F reboot || who -b').and_return(:boot_time_command_stub)
 
         allow(boot_time_initial_response).to receive(:stdout).and_return(boot_time_initial_stdout)
         allow(boot_time_success_response).to receive(:stdout).and_return(boot_time_success_stdout)
@@ -190,116 +248,128 @@ module Beaker
       end
 
       context 'new boot time greater than old boot time' do
-        let (:boot_time_initial_stdout) { '      system boot  2020-05-13 03:51' }
-        let (:boot_time_success_stdout) { '      system boot  2020-05-13 03:52' }
-
-        it 'passes with defaults' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response)
-          # allow the second boot_time and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
-
-          expect(instance.reboot).to be(nil)
-        end
+        check_cmd_output.each do |check_os, cmd_opts|
+          cmd_opts.each do |cmd_name, cmd_outputs|
+            context "on '#{check_os}' with the '#{cmd_name}' command" do
+              let (:boot_time_initial_stdout) { cmd_outputs[:initial] }
+              let (:boot_time_success_stdout) { cmd_outputs[:success] }
+
+              it 'passes with defaults' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response)
+                # allow the second boot_time and the hash arguments in exec
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-        it 'passes with wait_time_parameter' do
-          expect(instance).to receive(:sleep).with(10)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
+                expect(instance.reboot).to be(nil)
+              end
 
-          expect(instance.reboot(10)).to be(nil)
-        end
+              it 'passes with wait_time_parameter' do
+                expect(instance).to receive(:sleep).with(10)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                # allow the second boot_time and the hash arguments in exec
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-        it 'passes with max_connection_tries parameter' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, hash_including(:max_connection_tries => 20)).and_return(boot_time_success_response).once
+                expect(instance.reboot(10)).to be(nil)
+              end
 
-          expect(instance.reboot(sleep_time, 20)).to be(nil)
-        end
+              it 'passes with max_connection_tries parameter' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                # allow the second boot_time and the hash arguments in exec
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, hash_including(:max_connection_tries => 20)).and_return(boot_time_success_response).once
 
-        context 'command errors' do
-          before :each do
-            allow(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          end
+                expect(instance.reboot(sleep_time, 20)).to be(nil)
+              end
 
-          it 'raises a reboot failure when command fails' do
-            expect(instance).not_to receive(:sleep)
-            expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Host::CommandFailure).once
+              context 'command errors' do
+                before :each do
+                  allow(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).at_least(:once)
+                end
 
-            expect{ instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Command failed when attempting to reboot: .*/)
-          end
+                it 'raises a reboot failure when command fails' do
+                  expect(instance).to receive(:sleep).at_least(:once)
+                  expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Host::CommandFailure).at_least(:once)
 
-          it 'raises a reboot failure when we receive an unexpected error' do
-            expect(instance).not_to receive(:sleep)
-            expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Net::SSH::HostKeyError).once
+                  expect{ instance.reboot }.to raise_error(Beaker::Host::CommandFailure)
+                end
 
-            expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unexpected exception in reboot: .*/)
-          end
+                it 'raises a reboot failure when we receive an unexpected error' do
+                  expect(instance).to receive(:sleep).at_least(:once)
+                  expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Net::SSH::HostKeyError).at_least(:once)
 
-          context 'incorrect time string' do
-            context 'original time' do
-              let (:boot_time_initial_stdout) { 'boot bad' }
+                  expect { instance.reboot }.to raise_error(Net::SSH::HostKeyError)
+                end
 
-              it 'raises a reboot failure' do
-                expect(instance).not_to receive(:sleep)
+                context 'incorrect time string' do
+                  context 'original time' do
+                    let (:boot_time_initial_stdout) { 'boot bad' }
 
-                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unable to parse time: .*/)
-              end
-            end
+                    it 'raises a reboot failure' do
+                      # Handle the 'retry'
+                      allow(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).at_least(:once)
 
-            context 'current time' do
-              let (:boot_time_success_stdout) { 'boot bad' }
+                      expect(instance).not_to receive(:sleep)
 
-              it 'raises a reboot failure' do
-                expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_return(response).once
-                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-                # allow the second boot_time and the hash arguments in exec, repeated 10 times by default
-                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
+                      expect { instance.reboot }.to raise_error(Beaker::Host::RebootWarning, /Found no valid times in .*/)
+                    end
+                  end
+
+                  context 'current time' do
+                    let (:boot_time_success_stdout) { 'boot bad' }
 
-                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unable to parse time: .*/)
+                    it 'raises a reboot failure' do
+                      expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_return(response).once
+                      expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                      # allow the second boot_time and the hash arguments in exec, repeated 10 times by default
+                      expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).at_least(:once)
+
+                      expect { instance.reboot(10,9,1) }.to raise_error(Beaker::Host::RebootWarning, /Found no valid times in .*/)
+                    end
+                  end
+                end
               end
             end
           end
         end
       end
 
-      context 'new boot time less than old boot time' do
-        let (:boot_time_initial_stdout) { '      system boot  2020-05-13 03:51' }
-        let (:boot_time_success_stdout) { '      system boot  2020-05-13 03:50' }
+      context 'system did not reboot' do
+        check_cmd_output.each do |check_os, cmd_opts|
+          cmd_opts.each do |cmd_name, cmd_outputs|
+            context "on '#{check_os}' with the '#{cmd_name}' command" do
+              let (:boot_time_initial_stdout) { cmd_outputs[:initial] }
+              let (:boot_time_success_stdout) { cmd_outputs[:initial] }
 
-        it 'raises RebootFailure' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+              it 'raises RebootFailure' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
 
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec, repeated 18 times by default in order to replicate the previous behavior of the ping based Host.down?
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).exactly(18).times
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-          expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
-        end
+                expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
+              end
 
-        it 'raises RebootFailure if the number of retries is changed' do
-          expect(instance).to receive(:sleep).with(sleep_time)
-          # bypass shutdown command itself
-          expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
-          # allow the second boot_time and the hash arguments in exec, repeated 10 times by default
-          expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).exactly(10).times
+              it 'raises RebootFailure if the number of retries is changed' do
+                expect(instance).to receive(:sleep).with(sleep_time)
+                # bypass shutdown command itself
+                expect(instance).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_initial_response).once
+                expect(instance).to receive( :exec ).with(:boot_time_command_stub, anything).and_return(boot_time_success_response).once
 
-          expect { instance.reboot(wait_time=sleep_time, max_connection_tries=9, boot_time_retries=10) }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
+                expect { instance.reboot(wait_time=sleep_time, max_connection_tries=9, boot_time_retries=10) }.to raise_error(Beaker::Host::RebootFailure, /Boot time did not reset/)
+              end
+            end
+          end
         end
       end
-
     end
 
     describe '#enable_remote_rsyslog' do