beaker 4.38.1 → 5.0.0

data/lib/beaker/platform.rb

@@ -6,40 +6,36 @@ module Beaker
     PLATFORMS = /^(alpine|huaweios|cisco_nexus|cisco_ios_xr|(free|open)bsd|osx|centos|fedora|debian|oracle|redhat|redhatfips|scientific|opensuse|sles|ubuntu|windows|solaris|aix|archlinux|el|eos|cumulus|f5|netscaler)\-.+\-.+$/
     # Platform version numbers vs. codenames conversion hash
     PLATFORM_VERSION_CODES =
-      { :debian => { "bullseye"  => "11",
-                     "buster"    => "10",
-                     "stretch"   => "9",
-                     "jessie"    => "8",
-                     "wheezy"    => "7",
-                     "squeeze"   => "6",
-                   },
-        :ubuntu => { "jammy"   => "2204",
-                     "focal"   => "2004",
-                     "eoan"    => "1910",
-                     "disco"   => "1904",
-                     "cosmic"  => "1810",
-                     "bionic"  => "1804",
-                     "artful"  => "1710",
-                     "zesty"   => "1704",
+      { :debian => { "bullseye" => "11",
+                     "buster" => "10",
+                     "stretch" => "9",
+                     "jessie" => "8",
+                     "wheezy" => "7",
+                     "squeeze" => "6", },
+        :ubuntu => { "jammy" => "2204",
+                     "focal" => "2004",
+                     "eoan" => "1910",
+                     "disco" => "1904",
+                     "cosmic" => "1810",
+                     "bionic" => "1804",
+                     "artful" => "1710",
+                     "zesty" => "1704",
                      "yakkety" => "1610",
-                     "xenial"  => "1604",
-                     "wily"    => "1510",
-                     "vivid"   => "1504",
-                     "utopic"  => "1410",
-                     "trusty"  => "1404",
-                     "saucy"   => "1310",
-                     "raring"  => "1304",
+                     "xenial" => "1604",
+                     "wily" => "1510",
+                     "vivid" => "1504",
+                     "utopic" => "1410",
+                     "trusty" => "1404",
+                     "saucy" => "1310",
+                     "raring" => "1304",
                      "quantal" => "1210",
                      "precise" => "1204",
-                     "lucid"   => "1004",
-                   },
-        :osx =>    { "highsierra" => "1013",
-                     "sierra"     => "1012",
-                     "elcapitan"  => "1011",
-                     "yosemite"   => "1010",
-                     "mavericks"  => "109",
-                   }
-      }
+                     "lucid" => "1004", },
+        :osx => { "highsierra" => "1013",
+                  "sierra" => "1012",
+                  "elcapitan" => "1011",
+                  "yosemite" => "1010",
+                  "mavericks" => "109", }, }
 
     # A string with the name of the platform.
     attr_reader :variant
@@ -82,9 +78,7 @@ module Beaker
     # * netscaler
     # * archlinux
     def initialize(name)
-      if name !~ PLATFORMS
-        raise ArgumentError, "Unsupported platform name #{name}"
-      end
+      raise ArgumentError, "Unsupported platform name #{name}" if !PLATFORMS.match?(name)
 
       super
 
@@ -94,15 +88,15 @@ module Beaker
       @version = version
       @codename = nil
 
-      if codename_version_hash
-        if codename_version_hash[version]
-          @codename = version
-          @version = codename_version_hash[version]
-        else
-          version = version.delete('.')
-          version_codename_hash = codename_version_hash.invert
-          @codename = version_codename_hash[version]
-        end
+      return unless codename_version_hash
+
+      if codename_version_hash[version]
+        @codename = version
+        @version = codename_version_hash[version]
+      else
+        version = version.delete('.')
+        version_codename_hash = codename_version_hash.invert
+        @codename = version_codename_hash[version]
       end
     end
 
@@ -118,9 +112,7 @@ module Beaker
     # @return [String] the platform string with the platform version represented as a codename
     def with_version_codename
       version_array = [@variant, @version, @arch]
-      if @codename
-        version_array = [@variant, @codename, @arch]
-      end
+      version_array = [@variant, @codename, @arch] if @codename
       return version_array.join('-')
     end
 

data/lib/beaker/result.rb

@@ -2,6 +2,7 @@ module Beaker
   class Result
     attr_accessor :host, :cmd, :exit_code, :stdout, :stderr, :output,
                   :raw_stdout, :raw_stderr, :raw_output
+
     def initialize(host, cmd)
       @host       = host
       @cmd        = cmd
@@ -19,11 +20,11 @@ module Beaker
     # This is also the lowest overhead place to normalize line endings, IIRC
     def finalize!
       @raw_stdout = @stdout
-      @stdout     = normalize_line_endings( convert( @stdout ) )
+      @stdout     = normalize_line_endings(convert(@stdout))
       @raw_stderr = @stderr
-      @stderr     = normalize_line_endings( convert( @stderr ) )
+      @stderr     = normalize_line_endings(convert(@stderr))
       @raw_output = @output
-      @output     = normalize_line_endings( convert( @output ) )
+      @output     = normalize_line_endings(convert(@output))
     end
 
     def normalize_line_endings string
@@ -33,15 +34,15 @@ module Beaker
     def convert string
       # Remove invalid and undefined UTF-8 character encodings
       string.to_s.force_encoding('UTF-8')
-      string.to_s.chars.select{|i| i.valid_encoding?}.join
+      string.to_s.chars.select { |i| i.valid_encoding? }.join
     end
 
     def log(logger)
       logger.debug "Exited: #{exit_code}" unless exit_code == 0 or !exit_code
     end
 
-    def formatted_output(limit=10)
-      @output.split("\n").last(limit).collect {|x| "\t" + x}.join("\n")
+    def formatted_output(limit = 10)
+      @output.split("\n").last(limit).collect { |x| "\t" + x }.join("\n")
     end
 
     def exit_code_in?(range)

data/lib/beaker/shared/error_handler.rb

@@ -1,17 +1,15 @@
 module Beaker
   module Shared
     module ErrorHandler
-
-    def report_and_raise(logger, e, msg)
-      logger.error "Failed: errored in #{msg}"
-      logger.error(e.inspect)
-      bt = e.backtrace
-      logger.pretty_backtrace(bt).each_line do |line|
-        logger.error(line)
+      def report_and_raise(logger, e, msg)
+        logger.error "Failed: errored in #{msg}"
+        logger.error(e.inspect)
+        bt = e.backtrace
+        logger.pretty_backtrace(bt).each_line do |line|
+          logger.error(line)
+        end
+        raise e
       end
-      raise e
-    end
-
     end
   end
 end

data/lib/beaker/shared/fog_credentials.rb

@@ -41,19 +41,15 @@ module Beaker
         rescue Psych::SyntaxError, Errno::ENOENT => e
           raise fog_credential_error fog_file_path, from_env, "(#{e.class}) #{e.message}"
         end
-        if fog == false # YAML.load => false for empty file
-          raise fog_credential_error fog_file_path, from_env, "is empty."
-        end
+        raise fog_credential_error fog_file_path, from_env, "is empty." if fog == false # YAML.load => false for empty file
+
         # transparently support symbols or strings for keys
         fog = StringifyHash.new.merge!(fog)
         # respect credential from env
         # @note ENV must be a string, e.g. "default" not ":default"
-        if ENV["FOG_CREDENTIAL"]
-          credential_group = ENV["FOG_CREDENTIAL"].to_sym
-        end
-        if not fog[credential_group]
-          raise fog_credential_error fog_file_path, from_env, "could not load the specified credential group '#{credential_group}'."
-        end
+        credential_group = ENV["FOG_CREDENTIAL"].to_sym if ENV["FOG_CREDENTIAL"]
+        raise fog_credential_error fog_file_path, from_env, "could not load the specified credential group '#{credential_group}'." if not fog[credential_group]
+
         fog[credential_group]
       end
     end

data/lib/beaker/shared/host_manager.rb

@@ -1,50 +1,50 @@
 module Beaker
   module Shared
-    #Methods for managing Hosts.
+    # Methods for managing Hosts.
     #- selecting hosts by role (Symbol or String)
     #- selecting hosts by name (String)
     #- adding additional method definitions for selecting by role
     #- executing blocks of code against selected sets of hosts
     module HostManager
-
-      #Find hosts from a given array of hosts that all have the desired role.
-      #@param [Array<Host>] hosts The hosts to examine
-      #@param [String] desired_role The hosts returned will have this role in their roles list
-      #@return [Array<Host>] The hosts that have the desired role in their roles list
+      # Find hosts from a given array of hosts that all have the desired role.
+      # @param [Array<Host>] hosts The hosts to examine
+      # @param [String] desired_role The hosts returned will have this role in their roles list
+      # @return [Array<Host>] The hosts that have the desired role in their roles list
       def hosts_with_role(hosts, desired_role = nil)
         hosts.select do |host|
           desired_role.nil? or host['roles'].include?(desired_role.to_s)
         end
       end
 
-      #Find hosts from a given array of hosts that all have the desired name, match against host name,
-      #vmhostname and ip (the three valid ways to identify an individual host)
-      #@param [Array<Host>] hosts The hosts to examine
-      #@param [String] name The hosts returned will have this name/vmhostname/ip
-      #@return [Array<Host>] The hosts that have the desired name/vmhostname/ip
+      # Find hosts from a given array of hosts that all have the desired name, match against host name,
+      # vmhostname and ip (the three valid ways to identify an individual host)
+      # @param [Array<Host>] hosts The hosts to examine
+      # @param [String] name The hosts returned will have this name/vmhostname/ip
+      # @return [Array<Host>] The hosts that have the desired name/vmhostname/ip
       def hosts_with_name(hosts, name = nil)
         hosts.select do |host|
-          name.nil? or host.name =~ /\A#{name}/ or host[:vmhostname] =~ /\A#{name}/ or host[:ip] =~ /\A#{name}/
+          name.nil? or host.name&.start_with?(name) or host[:vmhostname]&.start_with?(name) or host[:ip]&.start_with?(name)
         end
       end
 
-      #Find a single host with the role provided.  Raise an error if more than one host is found to have the
-      #provided role.
-      #@param [Array<Host>] hosts The hosts to examine
-      #@param [String] role The host returned will have this role in its role list
-      #@return [Host] The single host with the desired role in its roles list
-      #@raise [ArgumentError] Raised if more than one host has the given role defined, if no host has the
+      # Find a single host with the role provided.  Raise an error if more than one host is found to have the
+      # provided role.
+      # @param [Array<Host>] hosts The hosts to examine
+      # @param [String] role The host returned will have this role in its role list
+      # @return [Host] The single host with the desired role in its roles list
+      # @raise [ArgumentError] Raised if more than one host has the given role defined, if no host has the
       #                       role defined, or if role = nil since hosts_with_role(nil) returns all hosts.
       def only_host_with_role(hosts, role)
         raise ArgumentError, "role cannot be nil." if role.nil?
+
         a_host = hosts_with_role(hosts, role)
-        case
-          when a_host.length == 0
-            raise ArgumentError, "There should be one host with #{role} defined!"
-          when a_host.length > 1
-            host_string = ( a_host.map { |host| host.name } ).join( ', ')
-            raise ArgumentError, "There should be only one host with #{role} defined, but I found #{a_host.length} (#{host_string})"
+        if a_host.length == 0
+          raise ArgumentError, "There should be one host with #{role} defined!"
+        elsif a_host.length > 1
+          host_string = (a_host.map { |host| host.name }).join(', ')
+          raise ArgumentError, "There should be only one host with #{role} defined, but I found #{a_host.length} (#{host_string})"
         end
+
         a_host.first
       end
 
@@ -58,17 +58,17 @@ module Beaker
       #   or if role = nil since hosts_with_role(nil) returns all hosts.
       def find_at_most_one_host_with_role(hosts, role)
         raise ArgumentError, "role cannot be nil." if role.nil?
+
         role_hosts = hosts_with_role(hosts, role)
-        host_with_role = nil
         case role_hosts.length
         when 0
+          nil
         when 1
-          host_with_role = role_hosts[0]
+          role_hosts[0]
         else
-          host_string = ( role_hosts.map { |host| host.name } ).join( ', ')
+          host_string = (role_hosts.map { |host| host.name }).join(', ')
           raise ArgumentError, "There should be only one host with #{role} defined, but I found #{role_hosts.length} (#{host_string})"
         end
-        host_with_role
       end
 
       # Execute a block selecting the hosts that match with the provided criteria
@@ -89,28 +89,25 @@ module Beaker
       #   and thus a result object is returned.
       def run_block_on hosts = [], filter = nil, opts = {}, &block
         result = nil
-        block_hosts = hosts #the hosts to apply the block to after any filtering
+        block_hosts = hosts # the hosts to apply the block to after any filtering
         if filter
-          if not hosts.empty?
-            block_hosts = hosts_with_role(hosts, filter) #check by role
-            if block_hosts.empty?
-              block_hosts = hosts_with_name(hosts, filter) #check by name
-            end
-            if block_hosts.length == 1  #we only found one matching host, don't need it wrapped in an array
-              block_hosts = block_hosts.pop
-            end
-          else
-            raise ArgumentError, "Unable to sort for #{filter} type hosts when provided with [] as Hosts"
+          raise ArgumentError, "Unable to sort for #{filter} type hosts when provided with [] as Hosts" if hosts.empty?
+
+          block_hosts = hosts_with_role(hosts, filter) # check by role
+          if block_hosts.empty?
+            block_hosts = hosts_with_name(hosts, filter) # check by name
           end
+          block_hosts = block_hosts.pop if block_hosts.length == 1 # we only found one matching host, don't need it wrapped in an array
+
         end
         if block_hosts.is_a? Array
           if block_hosts.length > 0
             if run_in_parallel? opts
               # Pass caller[1] - the line that called block_on - for logging purposes.
-              result = block_hosts.map.each_in_parallel(caller[1]) do |h|
+              result = block_hosts.map.each_in_parallel(caller(2..2).first) do |h|
                 run_block_on h, &block
               end
-              hosts.each{|host| host.close}# For some reason, I have to close the SSH connection
+              hosts.each { |host| host.close } # For some reason, I have to close the SSH connection
               # after spawning a process and running commands on a host,
               # or else it gets into a broken state for the next call.
             else
@@ -118,20 +115,17 @@ module Beaker
                 run_block_on h, &block
               end
             end
-          else
+          elsif (cur_logger = (logger || @logger))
             # there are no matching hosts to execute against
             # should warn here
             # check if logger is defined in this context
-            if ( cur_logger = (logger || @logger ) )
-              cur_logger.info "Attempting to execute against an empty array of hosts (#{hosts}, filtered to #{block_hosts}), no execution will occur"
-            end
+            cur_logger.info "Attempting to execute against an empty array of hosts (#{hosts}, filtered to #{block_hosts}), no execution will occur"
           end
         else
           result = yield block_hosts
         end
         result
       end
-
     end
   end
 end

data/lib/beaker/shared/options_resolver.rb

@@ -23,16 +23,12 @@ module Beaker
       #
       #   run_in_parallel?({:run_in_parallel => false}, {:run_in_parallel => ['install','configure']}, 'install')
       #   -> will return false
-      def run_in_parallel?(local_options=nil, global_options=nil, mode=nil)
+      def run_in_parallel?(local_options = nil, global_options = nil, mode = nil)
         run_in_parallel = local_options[:run_in_parallel] unless local_options.nil?
 
-        if !run_in_parallel.nil? && run_in_parallel.is_a?(Array)
-          run_in_parallel = false
-        end
+        run_in_parallel = false if !run_in_parallel.nil? && run_in_parallel.is_a?(Array)
 
-        if run_in_parallel.nil? && global_options && global_options[:run_in_parallel].is_a?(Array)
-          run_in_parallel = global_options[:run_in_parallel].include?(mode)
-        end
+        run_in_parallel = global_options[:run_in_parallel].include?(mode) if run_in_parallel.nil? && global_options && global_options[:run_in_parallel].is_a?(Array)
 
         run_in_parallel
       end

data/lib/beaker/shared/repetition.rb

@@ -1,28 +1,27 @@
 module Beaker
   module Shared
     module Repetition
-
       def repeat_for seconds, &block
         # do not peg CPU if &block takes less than 1 second
         repeat_for_and_wait seconds, 1, &block
       end
 
-      def repeat_for_and_wait seconds, wait, &block
+      def repeat_for_and_wait seconds, wait
         timeout = Time.now + seconds
         done = false
-        until done or timeout < Time.now do
-          done = block.call
+        until done or timeout < Time.now
+          done = yield
           sleep wait unless done
         end
         return done
       end
 
-      def repeat_fibonacci_style_for attempts, &block
+      def repeat_fibonacci_style_for attempts
         done = false
         attempt = 1
         last_wait, wait = 0, 1
-        while not done and attempt <= attempts do
-          done = block.call
+        while not done and attempt <= attempts
+          done = yield
           attempt += 1
           sleep wait unless done
           last_wait, wait = wait, last_wait + wait
@@ -32,4 +31,3 @@ module Beaker
     end
   end
 end
-

data/lib/beaker/shared/semvar.rb

@@ -1,38 +1,34 @@
 module Beaker
   module Shared
     module Semvar
-
-      #Is semver-ish version a less than semver-ish version b
-      #@param [String] a A version of the from '\d.\d.\d.*'
-      #@param [String] b A version of the form '\d.\d.\d.*'
-      #@return [Boolean] true if a is less than b, otherwise return false
+      # Is semver-ish version a less than semver-ish version b
+      # @param [String] a A version of the from '\d.\d.\d.*'
+      # @param [String] b A version of the form '\d.\d.\d.*'
+      # @return [Boolean] true if a is less than b, otherwise return false
       #
-      #@note This has been updated for our current versioning scheme.
-      #@note 2019.5.0 is greater than 2019.5.0-rc0
-      #@note 2019.5.0-rc0-1-gabc1234 is greater than 2019.5.0-rc0
-      #@note 2019.5.0-rc1 is greater than 2019.5.0-rc0-1-gabc1234
-      #@note 2019.5.0-1-gabc1234 is greater than 2019.5.0
+      # @note This has been updated for our current versioning scheme.
+      # @note 2019.5.0 is greater than 2019.5.0-rc0
+      # @note 2019.5.0-rc0-1-gabc1234 is greater than 2019.5.0-rc0
+      # @note 2019.5.0-rc1 is greater than 2019.5.0-rc0-1-gabc1234
+      # @note 2019.5.0-1-gabc1234 is greater than 2019.5.0
       def version_is_less a, b
         a_nums = a.split('-')[0].split('.')
         b_nums = b.split('-')[0].split('.')
         (0...a_nums.length).each do |i|
-          if i < b_nums.length
-            if a_nums[i].to_i < b_nums[i].to_i
-              return true
-            elsif a_nums[i].to_i > b_nums[i].to_i
-              return false
-            end
-          else
+          return false unless i < b_nums.length
+          if a_nums[i].to_i < b_nums[i].to_i
+            return true
+          elsif a_nums[i].to_i > b_nums[i].to_i
             return false
           end
         end
-        #checks all dots, they are equal so examine the rest
+        # checks all dots, they are equal so examine the rest
         a_rest = a.split('-').drop(1)
         a_is_release = a_rest.empty?
-        a_is_rc = !a_is_release && !!(a_rest[0] =~ /rc\d+/)
+        a_is_rc = !a_is_release && /rc\d+/.match?(a_rest[0])
         b_rest = b.split('-').drop(1)
         b_is_release = b_rest.empty?
-        b_is_rc = !b_is_release && !!(b_rest[0] =~ /rc\d+/)
+        b_is_rc = !b_is_release && /rc\d+/.match?(b_rest[0])
 
         if a_is_release && b_is_release
           # They are equal
@@ -40,29 +36,28 @@ module Beaker
         elsif !a_is_release && !b_is_release
           a_next = a_rest.shift
           b_next = b_rest.shift
-          if a_is_rc && b_is_rc
-            a_rc = a_next.gsub('rc','').to_i
-            b_rc = b_next.gsub('rc','').to_i
-            if a_rc < b_rc
-              return true
-            elsif a_rc > b_rc
-              return false
-            else
-              a_next = a_rest.shift
-              b_next = b_rest.shift
-              if a_next && b_next
-                return a_next.to_i < b_next.to_i
-              else
-                # If a has nothing after -rc#, it is a tagged RC and 
-                # b must be a later build after this tag.
-                return a_next.nil?
-              end
-            end
+          return a_is_rc unless a_is_rc && b_is_rc
+
+          a_rc = a_next.gsub('rc', '').to_i
+          b_rc = b_next.gsub('rc', '').to_i
+          if a_rc < b_rc
+            return true
+          elsif a_rc > b_rc
+            return false
           else
-            # If one of them is not an rc (and also not a release), 
-            # that one is a post-release build. So if a is the RC, it is less.
-            return a_is_rc
+            a_next = a_rest.shift
+            b_next = b_rest.shift
+            return a_next.to_i < b_next.to_i if a_next && b_next
+
+            # If a has nothing after -rc#, it is a tagged RC and
+            # b must be a later build after this tag.
+            return a_next.nil?
+
           end
+
+        # If one of them is not an rc (and also not a release),
+        # that one is a post-release build. So if a is the RC, it is less.
+
         else
           return (b_is_release && a_is_rc) || (a_is_release && !b_is_rc)
         end
@@ -78,12 +73,14 @@ module Beaker
       #
       # @return [String, nil] the max string out of the versions list or the
       #   default value if the list is faulty, which can either be set or nil
-      def max_version(versions, default=nil)
+      def max_version(versions, default = nil)
         return default if !versions || versions.empty?
+
         versions_copy = versions.dup
         highest = versions_copy.shift
         versions_copy.each do |version|
           next if !version
+
           highest = version if version_is_less(highest, version)
         end
         highest
@@ -91,4 +88,3 @@ module Beaker
     end
   end
 end
-

data/lib/beaker/shared/timed.rb

@@ -1,14 +1,11 @@
 module Beaker
   module Shared
     module Timed
-
-      def run_and_report_duration &block
+      def run_and_report_duration
         start = Time.now
-        block.call
+        yield
         Time.now - start
       end
-
     end
   end
 end
-

data/lib/beaker/shared.rb

@@ -1,4 +1,4 @@
-[ 'repetition', 'error_handler', 'host_manager', 'timed', 'semvar', 'options_resolver', 'fog_credentials'].each do |lib|
+%w[repetition error_handler host_manager timed semvar options_resolver fog_credentials].each do |lib|
   require "beaker/shared/#{lib}"
 end
 module Beaker