beaker 4.15.0 → 4.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 202dc17b3f60a07a9a96bd16a252cbca228cca4ae969fc38595e2f1e0806415d
-  data.tar.gz: 99d2385877a317dac33c2500fab84ede0a6890dd64a3b29015e50c5c0230bee4
+  metadata.gz: 47866cdc1343ec3c973731ac22f559a8c8bb9191a28b5e0fa502b0161dc77869
+  data.tar.gz: 2120cec9e0a21b849ec959456ccb5c48fefd9f0816ad219cc5e82317147ce53e
 SHA512:
-  metadata.gz: 9658a076c692a948f6d56b18ae975d02064179d51c9500c83b6acd60cc8a777234fccf573ac068c3ccdff19d481658beee28506f890ea9af03558eaa3d4484ba
-  data.tar.gz: efa9b80bae656f0daf6c53c9ac9d5e07f1a537b72bfe1a10d6fb66fa4c8e545e5a7a38a82bf9da121a93a194ed5e89f7ec53a033d412da1d936320e74927fdf6
+  metadata.gz: c351c5016c60b958a81bb4ab75a01f059ec679690b9c2e72d0664b45cb2cba3a98aa765be65c81f8518dfa6e84bc59fc959c3ac940641050f000799014d0b35f
+  data.tar.gz: 04935abd0b44d9bb222548af8281ff5b9ee0694ede3e97c91df6c77ca31ef242d9fed732eb52b4f658c7182a6f2e886c99eeac34ce2f6551156cadf31ccace80

data/CHANGELOG.md

@@ -11,7 +11,18 @@ Tracking in this Changelog began for this project in version 3.25.0.
 If you're looking for changes from before this, refer to the project's
 git logs & PR history.
 
-# [Unreleased](https://github.com/puppetlabs/beaker/compare/4.15.0...master)
+# [Unreleased](https://github.com/puppetlabs/beaker/compare/4.16.0...master)
+
+# [4.16.0](https://github.com/puppetlabs/beaker/compare/4.15.0...4.16.0) - 2020-02-05
+
+### Added
+
+- release section to README ([#1618](https://github.com/puppetlabs/beaker/pull/1618))
+- false return if `link_exists?` raises an error ([#1613](https://github.com/puppetlabs/beaker/pull/1613))
+
+### Fixed
+
+- `host.reboot` uses `uptime` rather than `ping` to check host status ([#1619](https://github.com/puppetlabs/beaker/pull/1619))
 
 # [4.15.0](https://github.com/puppetlabs/beaker/compare/4.14.1...4.15.0) - 2020-01-30
 

data/README.md

@@ -40,4 +40,13 @@ If you'd like to contribute improvements to Beaker, please see [CONTRIBUTING](CO
 
 # Maintainers
 
-For information on project maintainers, please check out our [MAINTAINERS doc](MAINTAINERS.md).
+For information on project maintainers, please check out our [CODEOWNERS doc](CODEOWNERS).
+
+# Releasing
+
+Since the beaker project has always been the central hub for all beaker testing, its release process has been more involved than most beaker-libraries (ie. [beaker-puppet](https://github.com/puppetlabs/beaker-puppet)).
+Historically, the process has been described in [Confluence: Beaker Release Process](https://confluence.puppetlabs.com/display/SRE/Beaker+Release+Process) (apologies, most links in this section are Puppet-internal).
+
+To release new versions of beaker, please use this [jenkins job](https://jenkins-sre.delivery.puppetlabs.net/view/all/job/qe_beaker-gem_init-multijob_master/). This job lives on internal infrastructure.
+
+To run the job, click on `Build with Parameters` in the menu on the left. Make sure you verify the checkbox next to `PUBLIC` is checked and enter the appropriate version. The version should adhere to semantic version standards. When in doubt, consult [the maintainers of Beaker](#maintainers) for guidance.

data/beaker.gemspec

@@ -45,7 +45,6 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'hocon', '~> 1.0'
   s.add_runtime_dependency 'net-ssh', '~> 5.0'
   s.add_runtime_dependency 'net-scp', '~> 1.2'
-  s.add_runtime_dependency 'net-ping', '~> 2.0'
   s.add_runtime_dependency 'inifile', '~> 3.0'
 
   s.add_runtime_dependency 'rsync', '~> 1.0.9'

data/lib/beaker/dsl/helpers/web_helpers.rb

@@ -18,15 +18,19 @@ module Beaker
         #@example
         #  extension = link_exists?("#{URL}.tar.gz") ? ".tar.gz" : ".tar"
         def link_exists?(link)
-          require "net/http"
-          require "net/https"
-          require "open-uri"
-          url = URI.parse(link)
-          http = Net::HTTP.new(url.host, url.port)
-          http.use_ssl = (url.scheme == 'https')
-          http.verify_mode = (OpenSSL::SSL::VERIFY_NONE)
-          http.start do |http|
-            return http.head(url.request_uri).code == "200"
+          begin
+            require "net/http"
+            require "net/https"
+            require "open-uri"
+            url = URI.parse(link)
+            http = Net::HTTP.new(url.host, url.port)
+            http.use_ssl = (url.scheme == 'https')
+            http.verify_mode = (OpenSSL::SSL::VERIFY_NONE)
+            http.start do |http|
+              return http.head(url.request_uri).code == "200"
+            end
+          rescue
+            return false
           end
         end
 

data/lib/beaker/host.rb

@@ -2,7 +2,6 @@ require 'socket'
 require 'timeout'
 require 'benchmark'
 require 'rsync'
-require 'net/ping'
 
 require 'beaker/dsl/helpers'
 require 'beaker/dsl/patterns'
@@ -594,27 +593,6 @@ module Beaker
       return result if result.success?
       raise Beaker::Host::CommandFailure, result.error
     end
-
-    def ping?
-      check = Net::Ping::External.new(self)
-      check.ping?
-    end
-
-    def down?
-      @logger.debug("host.down?: checking if host has gone down using ping...")
-      host_up = true
-      # give it max 3 minutes to go down, check every 10 seconds
-      repeat_for_and_wait 180, 10 do
-        host_up = self.ping?
-        @logger.debug("- ping result: #{host_up}. Done checking? #{!host_up}")
-        !host_up # host down? -> continue looping. up? -> finished
-      end
-      if host_up
-        raise Beaker::Host::RebootFailure, 'Host failed to go down'
-      end
-      @logger.debug("host.down? host stopped responding, returning true")
-      true
-    end
   end
 
   [

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

@@ -1,22 +1,75 @@
 module Unix::Exec
   include Beaker::CommandFactory
 
+  # Reboots the host, comparing uptime values to verify success
+  #
+  # Will throw an exception RebootFailure if it fails
   def reboot
-    if self['platform'] =~ /solaris/
-      exec(Beaker::Command.new("reboot"), :expect_connection_failure => true)
-    else
-      exec(Beaker::Command.new("/sbin/shutdown -r now"), :expect_connection_failure => true)
-    end
-    down? # Verify the host went down
     begin
-      exec(Beaker::Command.new("exit"))
+      original_uptime = exec(Beaker::Command.new("uptime"))
+      original_uptime_str = parse_uptime original_uptime.stdout
+      original_uptime_int = uptime_int original_uptime_str
+
+      if self['platform'] =~ /solaris/
+        exec(Beaker::Command.new("reboot"), :expect_connection_failure => true)
+      else
+        exec(Beaker::Command.new("/sbin/shutdown -r now"), :expect_connection_failure => true)
+      end
+
+      # give the host a little time to shutdown
+      sleep 5 
+
+      #use uptime to check if the host has rebooted
+      current_uptime_exec = exec(Beaker::Command.new("uptime"), {:max_connection_tries => 9, :silent => true})
+      current_uptime = current_uptime_exec.stdout
+      current_uptime_str = parse_uptime current_uptime
+      current_uptime_int = uptime_int current_uptime_str
+      unless original_uptime_int > current_uptime_int
+        raise Beaker::Host::RebootFailure, "Uptime did not reset. Reboot appears to have failed."
+      end
     rescue Beaker::Host::CommandFailure => e
       raise Beaker::Host::RebootFailure, "Command failed in reboot: #{e.message}"
-    rescue Exception => e
+    rescue RuntimeError => e
       raise Beaker::Host::RebootFailure, "Unexpected exception in reboot: #{e.message}"
     end
   end
 
+  def uptime_int(uptime_str)
+    time_array = uptime_str.split(", ")
+    accumulated_mins = 0
+    time_array.each do |time_segment|
+      value, unit = time_segment.split
+      if unit.nil?
+        # 20:47 case: hours & mins
+        hours, mins = value.split(":")
+        accumulated_mins += (hours.to_i * 60 + mins.to_i)
+      elsif unit =~ /day(s)?/
+        accumulated_mins += (value.to_i * 1440) # 60 * 24 = 1440
+      elsif unit =~ /min(s)?/
+        accumulated_mins += value.to_i
+      else
+        raise ArgumentError, "can't parse uptime segment: #{time_segment}"
+      end
+    end
+
+    accumulated_mins
+  end
+
+  def parse_uptime(uptime)
+    # get String from up to users
+    # eg 19:52  up 14 mins, 2 users, load averages: 2.95 4.19 4.31
+    # 8:03 up 52 days, 20:47, 3 users, load averages: 1.36 1.42 1.40
+    # 22:19 up 54 days, 1 min, 4 users, load averages: 2.08 2.06 2.27
+    regexp = /.*up (.*)[[:space:]]+[[:digit:]]+ user.*/
+    result = uptime.match regexp
+    if self['platform'] =~ /solaris-/ && result[1].empty?
+      return "0 min"
+    end
+    raise "Couldn't parse uptime: #{uptime}" if result.nil?
+    
+    result[1].strip.chomp(",")
+  end
+
   def echo(msg, abs=true)
     (abs ? '/bin/echo' : 'echo') + " #{msg}"
   end

data/lib/beaker/ssh_connection.rb

@@ -44,37 +44,59 @@ module Beaker
       connection
     end
 
-    def connect_block host, user, ssh_opts
+    # Setup and return the ssh connection object
+    #
+    # @note For more information about Net::SSH library, check out these docs:
+    #       - {https://net-ssh.github.io/net-ssh/ Base Net::SSH docs}
+    #       - {http://net-ssh.github.io/net-ssh/Net/SSH.html#method-c-start Net::SSH.start method docs}
+    #       - {https://net-ssh.github.io/net-ssh/Net/SSH/Connection/Session.html Net::SSH::Connection::Session class docs}
+    #
+    # @param [String] host hostname of the machine to connect to
+    # @param [String] user username to login to the host as
+    # @param [Hash{Symbol=>String}] ssh_opts Options hash passed directly to Net::SSH.start method
+    # @param [Hash{Symbol=>String}] options Options hash to control method conditionals
+    # @option options [Integer] :max_connection_tries Limit the number of connection start
+    #                                                 tries to this number (default: 11)
+    # @option options [Boolean] :silent Stops logging attempt failure messages if set to true
+    #                                   (default: true)
+    #
+    # @return [Net::SSH::Connection::Session] session returned from Net::SSH.start method
+    def connect_block host, user, ssh_opts, options
       try = 1
       last_wait = 2
       wait = 3
+      max_connection_tries = options[:max_connection_tries] || 11
       begin
          @logger.debug "Attempting ssh connection to #{host}, user: #{user}, opts: #{ssh_opts}"
          Net::SSH.start(host, user, ssh_opts)
        rescue *RETRYABLE_EXCEPTIONS => e
-         if try <= 11
-           @logger.warn "Try #{try} -- Host #{host} unreachable: #{e.class.name} - #{e.message}"
-           @logger.warn "Trying again in #{wait} seconds"
+         if try <= max_connection_tries
+           @logger.warn "Try #{try} -- Host #{host} unreachable: #{e.class.name} - #{e.message}" unless options[:silent]
+           @logger.warn "Trying again in #{wait} seconds" unless options[:silent]
            sleep wait
           (last_wait, wait) = wait, last_wait + wait
            try += 1
            retry
          else
-           @logger.warn "Failed to connect to #{host}, after #{try} attempts"
+           @logger.warn "Failed to connect to #{host}, after #{try} attempts" unless options[:silent]
            nil
          end
        end
     end
 
-    # connect to the host
-    def connect
+    # Connect to the host, creating a new connection if required
+    #
+    # @param [Hash{Symbol=>String}] options Options hash to control method conditionals
+    # @option options [Integer] :max_connection_tries {#connect_block} option
+    # @option options [Boolean] :silent {#connect_block} option
+    def connect options = {}
       # Try three ways to connect to host (vmhostname, ip, hostname)
       # Try each method in turn until we succeed
       methods = @ssh_connection_preference.dup
       while (not @ssh) && (not methods.empty?) do
         unless instance_variable_get("@#{methods[0]}").nil?
           if SUPPORTED_CONNECTION_METHODS.include?(methods[0])
-            @ssh = connect_block(instance_variable_get("@#{methods[0].to_s}"), @user, @ssh_opts)
+            @ssh = connect_block(instance_variable_get("@#{methods[0].to_s}"), @user, @ssh_opts, options)
           else
             @logger.warn "Beaker does not support #{methods[0]} to SSH to host, trying next available method."
             @ssh_connection_preference.delete(methods[0])
@@ -196,10 +218,15 @@ module Beaker
       result
     end
 
+    # Execute a command on a host, ensuring a connection exists first
+    #
+    # @param [Hash{Symbol=>String}] options Options hash to control method conditionals
+    # @option options [Integer] :max_connection_tries {#connect_block} option (passed through {#connect})
+    # @option options [Boolean] :silent {#connect_block} option (passed through {#connect})
     def execute command, options = {}, stdout_callback = nil,
                 stderr_callback = stdout_callback
       # ensure that we have a current connection object
-      connect
+      connect(options)
       try_to_execute(command, options, stdout_callback, stderr_callback)
     end
 

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '4.15.0'
+    STRING = '4.16.0'
   end
 end

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

@@ -159,19 +159,36 @@ module Beaker
     end
 
     describe '#reboot' do
+      let (:response) { double( 'response' ) }
+
       before :each do
-        expect(instance).to receive(:exec).and_return(false)
-        expect(instance).to receive(:down?)
+        # stubs enough to survive the first uptime call & output parsing
+        #   note: just stubs input-chain between calls, parsing methods still run
+        allow( Beaker::Command ).to receive(:new).with("uptime").and_return(:uptime_command_stub)
+        allow( instance ).to receive( :exec ).with(:uptime_command_stub).and_return(response)
+        allow( response ).to receive(:stdout).and_return('19:52  up 14 mins, 2 users, load averages: 2.95 4.19 4.31')
+
+        allow( Beaker::Command ).to receive(:new).with("/sbin/shutdown -r now").and_return(:shutdown_command_stub)
       end
+
       it 'raises a reboot failure when command fails' do
-        expect(instance).to receive(:exec).and_raise(Host::CommandFailure)
+        expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Host::CommandFailure)
         expect{ instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Command failed in reboot: .*/)
       end
 
       it 'raises a reboot failure when we receive an unexpected error' do
-        expect(instance).to receive(:exec).and_raise(Net::SSH::HostKeyError)
+        expect(instance).to receive(:exec).with(:shutdown_command_stub, anything).and_raise(Net::SSH::HostKeyError)
         expect{ instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Unexpected exception in reboot: .*/)
       end
+
+      it 'raises RebootFailure if new uptime is never less than old uptime' do
+        # bypass shutdown command itself
+        allow( instance ).to receive( :exec ).with(:shutdown_command_stub, anything).and_return(response)
+        # allow the second uptime and the hash arguments in exec
+        allow( instance ).to receive( :exec ).with(:uptime_command_stub, anything).and_return(response)
+
+        expect { instance.reboot }.to raise_error(Beaker::Host::RebootFailure, /Uptime did not reset/)
+      end
     end
 
     describe '#enable_remote_rsyslog' do
@@ -184,5 +201,42 @@ module Beaker
       end
 
     end
+
+    describe '#parse_uptime' do
+      it 'parses variation of uptime string' do
+        expect(instance.parse_uptime("19:52  up 14 mins, 2 users, load averages: 2.95 4.19 4.31")).to be == "14 mins"
+      end
+      it 'parses variation 2 of uptime string' do
+        expect(instance.parse_uptime("8:03 up 52 days, 20:47, 3 users, load averages: 1.36 1.42 1.40")).to be == "52 days, 20:47"
+      end
+      it 'parses variation 3 of uptime string' do
+        expect(instance.parse_uptime("22:19 up 54 days, 1 min, 4 users, load averages: 2.08 2.06 2.27")).to be == "54 days, 1 min"
+      end
+      it 'parses variation 4 of uptime string' do
+        expect(instance.parse_uptime("18:44:45 up 5 min,  0 users,  load average: 0.14, 0.11, 0.05")).to be == "5 min"
+      end
+      it 'parses solaris\'s "just up" without time message' do
+        opts['platform'] = 'solaris-11-x86_64'
+        expect(instance.parse_uptime("10:05am  up  0 users,  load average: 0.66, 0.14, 0.05")).to be == "0 min"
+      end
+     end
+
+    describe '#uptime_int' do
+      it 'parses time segment variation into a minute value' do
+        expect(instance.uptime_int("14 mins")).to be == 14
+      end
+      it 'parses time segment variation 2 into a minute value' do
+        expect(instance.uptime_int("52 days, 20:47")).to be == 76127
+      end
+      it 'parses time segment variation 3 into a minute value' do
+        expect(instance.uptime_int("54 days, 1 min")).to be == 77761
+        end
+      it 'parses time segment variation 4 into a minute value' do
+        expect(instance.uptime_int("54 days")).to be == 77760
+      end
+      it 'raises if we pass garbage to it' do
+        expect { instance.uptime_int("solaris roxx my soxx") }.to raise_error
+      end
+    end
   end
 end

data/spec/beaker/host_spec.rb

@@ -825,30 +825,6 @@ module Beaker
       end
     end
 
-    describe "#down?" do
-
-      it "repeats & fails with 'failed to go down' after X seconds" do
-        allow(host).to receive(:repeat_for_and_wait).with(180,10).and_return(false)
-        expect {
-          host.down?
-        }.to raise_error(Beaker::Host::RebootFailure, "Host failed to go down")
-      end
-
-      it "returns that the host is down (true) if ping? is false" do
-        expect(host).to receive(:ping?).exactly(1).times.and_return(false)
-
-        expect(host.down?).to be true
-      end
-
-      it "cuts off execution correctly if host becomes unreachable" do
-        expect(host).to receive(:sleep).exactly(3).times
-        expect(host).to receive(:ping?).exactly(3).times.and_return(true).ordered
-        expect(host).to receive(:ping?).exactly(1).times.and_return(false).ordered
-
-        expect(host.down?).to be true
-      end
-    end
-
     describe "#fips_mode?" do
       it 'returns false on non-el7 hosts' do
         @platform = 'windows'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaker
 version: !ruby/object:Gem::Version
-  version: 4.15.0
+  version: 4.16.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-30 00:00:00.000000000 Z
+date: 2020-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -240,20 +240,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: net-ping
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: inifile
   requirement: !ruby/object:Gem::Requirement