beaker 2.46.0 → 2.47.0

data/docs/Shared-Options-for-Executing-Beaker-Commands.md

@@ -41,3 +41,9 @@ Do not output any logging for this command.  Defaults to `false`.
 Specifies standard input to be provided to the command post execution.  Defaults to `nil`.
 
     on host, "this command takes input", {:stdin => "hiya"}
+
+## [:run_in_parallel](runner/run_in_parallel.md)
+
+Execute the command against all hosts in parallel
+
+    on hosts, puppet( 'agent -t' ), :run_in_parallel => true

data/docs/runner/run_in_parallel.md

@@ -0,0 +1,62 @@
+# run_in_parallel global and command options
+
+## run_in_parallel global option
+The run_in_parallel global option is an array with the following possible values: ['configure', 'install']
+It defaults to an empty array []
+It can be set in an options file, or overriden by the BEAKER_RUN_IN_PARALLEL environment variable
+example:
+
+export BEAKER_RUN_IN_PARALLEL=configure,install
+
+Including 'configure' causes timesync to execute in parallel (if timesync=true for any host)
+
+Including 'install' causes as much of the puppet install to happen in parallel as possible.
+
+## run_in_parallel command option
+The run_in_parallel command option is a boolean value, specifying whether to execute each iteration (usually of hosts)
+in parallel, or not.  The block_on method is the primary method accepting the run_in_parallel command option,
+however many methods that call into block_on respect it as well:
+- on
+- run_block_on
+- block_on
+- install_puppet_agent_on
+- apply_manifest_on
+- stop_agent_on
+- execute_powershell_script_on
+
+## Using InParallel in your test scripts
+In addition to the options, you can use InParallel within your test scripts as well.
+
+Examples:
+```ruby
+include InParallel
+
+test_name('test_test')
+
+# Example 1
+hosts.each_in_parallel{ |host|
+    # Do something on each host
+}
+
+def some_method_call
+    return "some_method_call"
+end
+
+def some_method_call
+    return "some_other_method_call"
+end
+
+# Example 2
+# Runs each method within the block in parallel in a forked process
+run_in_parallel{
+    @result = some_method_call
+    @result_2 = some_other_method_call
+}
+
+# results in 'some_method_callsome_other_method_call'
+puts @result + @result_2
+```
+
+**_Note:_** While you can return a result from a forked process to an instance variable, any values assigned to local variables, or other changes to global state will not persist from the child process to the parent process.
+
+Further documentation on the usage of [InParallel](http://github/puppetlabs/in-parallel/readme.md)

data/lib/beaker.rb

@@ -29,7 +29,10 @@ module Beaker
   #
   # Common setup and testing steps
   #require 'beaker/steps'
-  #
+
+  # InParallel, for executing in parallel
+  require 'in_parallel'
+
   # Shared methods and helpers
   require 'beaker/shared'
 

data/lib/beaker/cli.rb

@@ -14,6 +14,7 @@ module Beaker
       @options_parser = Beaker::Options::Parser.new
       @options = @options_parser.parse_args
       @logger = Beaker::Logger.new(@options)
+      InParallel::InParallelExecutor.logger = @logger
       @options[:logger] = @logger
       @options[:timestamp] = @timestamp
       @options[:beaker_version] = Beaker::Version::STRING

data/lib/beaker/dsl.rb

@@ -56,8 +56,8 @@ module Beaker
   #     require 'spec_helper'
   #
   #     describe 'A Test With RSpec' do
-  #       let(:hosts)  { Host.new('blah', 'blah', 'not helpful' }
-  #       let(:logger) { Where.is('the', 'rspec', 'logger')     }
+  #       let(:hosts)  { Host.new('blah', 'blah', 'not helpful') }
+  #       let(:logger) { Where.is('the', 'rspec', 'logger')      }
   #
   #       after do
   #         on master, puppet('resource mything ensure=absent')

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

@@ -24,7 +24,7 @@ module Beaker
         #   @option opts [Hash{String=>String}] :environment ({}) These will be
         #     treated as extra environment variables that should be set before
         #     running the command.
-        #
+        #   @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
 
         # The primary method for executing commands *on* some set of hosts.
         #
@@ -60,7 +60,7 @@ module Beaker
         # @return [Result]   An object representing the outcome of *command*.
         # @raise  [FailTest] Raises an exception if *command* obviously fails.
         def on(host, command, opts = {}, &block)
-          block_on host do | host |
+          block_on host, opts do | host |
             if command.is_a? String
               cmd_opts = {}
               #add any additional environment variables to the command
@@ -280,10 +280,12 @@ module Beaker
         #                                 that responds like
         #                                 {Beaker::Host#do_scp_from}.
         # @param [String] powershell_script A string describing a set of powershell actions
+        # @param [Hash{Symbol=>String}] opts Options to alter execution.
+        # @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
         #
         # @return [Result] Returns the result of the powershell command execution
         def execute_powershell_script_on(hosts, powershell_script, opts = {})
-          block_on hosts do |host|
+          block_on hosts, opts do |host|
             script_path = "beaker_powershell_script_#{Time.now.to_i}.ps1"
             create_remote_file(host, script_path, powershell_script, opts)
             native_path = script_path.gsub(/\//, "\\")

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

@@ -397,6 +397,7 @@ module Beaker
         # @option opts [String]   :debug (false) If this option exists,
         #                         the "--debug" command line parameter
         #                         will be passed to the 'puppet apply' command.
+        # @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
         #
         # @param [Block] block This method will yield to a block of code passed
         #                      by the caller; this can be used for additional
@@ -405,7 +406,7 @@ module Beaker
         # @return [Array<Result>, Result, nil] An array of results, a result object,
         #   or nil. Check {#run_block_on} for more details on this.
         def apply_manifest_on(host, manifest, opts = {}, &block)
-          block_on host do | host |
+          block_on host, opts do | host |
             on_options = {}
             on_options[:acceptable_exit_codes] = Array(opts[:acceptable_exit_codes])
 
@@ -658,12 +659,14 @@ module Beaker
         #stops the puppet agent running on the host
         # @param [Host, Array<Host>, String, Symbol] agent    One or more hosts to act upon,
         #                            or a role (String or Symbol) that identifies one or more hosts.
-        def stop_agent_on(agent)
-          block_on agent do | host |
-            vardir = agent.puppet_configprint['vardir']
+        # @param [Hash{Symbol=>String}] opts Options to alter execution.
+        # @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
+        def stop_agent_on(agent, opts = {})
+          block_on agent, opts do | host |
+            vardir = host.puppet_configprint['vardir']
             agent_running = true
             while agent_running
-              agent_running = agent.file_exist?("#{vardir}/state/agent_catalog_run.lock")
+              agent_running = host.file_exist?("#{vardir}/state/agent_catalog_run.lock")
               if agent_running
                 sleep 2
               end
@@ -671,26 +674,26 @@ module Beaker
 
             # In 4.0 this was changed to just be `puppet`
             agent_service = 'puppet'
-            if !aio_version?(agent)
+            if !aio_version?(host)
               # The agent service is `pe-puppet` everywhere EXCEPT certain linux distros on PE 2.8
               # In all the case that it is different, this init script will exist. So we can assume
               # that if the script doesn't exist, we should just use `pe-puppet`
               agent_service = 'pe-puppet-agent'
-              agent_service = 'pe-puppet' unless agent.file_exist?('/etc/init.d/pe-puppet-agent')
+              agent_service = 'pe-puppet' unless host.file_exist?('/etc/init.d/pe-puppet-agent')
             end
 
             # Under a number of stupid circumstances, we can't stop the
             # agent using puppet.  This is usually because of issues with
             # the init script or system on that particular configuration.
             avoid_puppet_at_all_costs = false
-            avoid_puppet_at_all_costs ||= agent['platform'] =~ /el-4/
-            avoid_puppet_at_all_costs ||= agent['pe_ver'] && version_is_less(agent['pe_ver'], '3.2') && agent['platform'] =~ /sles/
+            avoid_puppet_at_all_costs ||= host['platform'] =~ /el-4/
+            avoid_puppet_at_all_costs ||= host['pe_ver'] && version_is_less(host['pe_ver'], '3.2') && host['platform'] =~ /sles/
 
             if avoid_puppet_at_all_costs
               # When upgrading, puppet is already stopped. On EL4, this causes an exit code of '1'
-              on agent, "/etc/init.d/#{agent_service} stop", :acceptable_exit_codes => [0, 1]
+              on host, "/etc/init.d/#{agent_service} stop", :acceptable_exit_codes => [0, 1]
             else
-              on agent, puppet_resource('service', agent_service, 'ensure=stopped')
+              on host, puppet_resource('service', agent_service, 'ensure=stopped')
             end
           end
         end
@@ -714,35 +717,52 @@ module Beaker
 
         # Ensure the host has requested a cert, then sign it
         #
-        # @param [Host, Array<Host>, String, Symbol] host    One or more hosts to act upon,
-        #                            or a role (String or Symbol) that identifies one or more hosts.
+        # @param [Host, Array<Host>, String, Symbol] host   One or more hosts, or a role (String or Symbol)
+        #                            that identifies one or more hosts to validate certificate signing.
+        #                            No argument, or an empty array means no validation of success
+        #                            for specific hosts will be performed. This will always execute
+        #                            'cert --sign --all --allow-dns-alt-names' even for a single host.
         #
         # @return nil
         # @raise [FailTest] if process times out
-        def sign_certificate_for(host)
-          block_on host do | host |
-            if [master, dashboard, database].include? host
+        def sign_certificate_for(host = [])
+          hostnames = []
+          hosts = host.is_a?(Array) ? host : [host]
+          hosts.each{ |current_host|
+            if [master, dashboard, database].include? current_host
 
-              on host, puppet( 'agent -t' ), :acceptable_exit_codes => [0,1,2]
-              on master, puppet( "cert --allow-dns-alt-names sign #{host}" ), :acceptable_exit_codes => [0,24]
+              on current_host, puppet( 'agent -t' ), :acceptable_exit_codes => [0,1,2]
+              on master, puppet( "cert --allow-dns-alt-names sign #{current_host}" ), :acceptable_exit_codes => [0,24]
 
             else
-
-              hostname = Regexp.escape host.node_name
-
-              last_sleep = 0
-              next_sleep = 1
-              (0..10).each do |i|
-                fail_test("Failed to sign cert for #{hostname}") if i == 10
-
-                on master, puppet("cert --sign --all --allow-dns-alt-names"), :acceptable_exit_codes => [0,24]
-                break if on(master, puppet("cert --list --all")).stdout =~ /\+ "?#{hostname}"?/
-                sleep next_sleep
-                (last_sleep, next_sleep) = next_sleep, last_sleep+next_sleep
+              hostnames << Regexp.escape( current_host.node_name )
+            end
+          }
+          if hostnames.size < 1
+            on master, puppet("cert --sign --all --allow-dns-alt-names"),
+               :acceptable_exit_codes => [0,24]
+            return
+          end
+          while hostnames.size > 0
+            last_sleep = 0
+            next_sleep = 1
+            (0..10).each do |i|
+              if i == 10
+                fail_test("Failed to sign cert for #{hostnames}")
+                hostnames.clear
+              end
+              on master, puppet("cert --sign --all --allow-dns-alt-names"), :acceptable_exit_codes => [0,24]
+              out = on(master, puppet("cert --list --all")).stdout
+              if hostnames.all? { |hostname| out =~ /\+ "?#{hostname}"?/ }
+                hostnames.clear
+                break
               end
 
+              sleep next_sleep
+              (last_sleep, next_sleep) = next_sleep, last_sleep+next_sleep
             end
           end
+          host
         end
 
         #prompt the master to sign certs then check to confirm the cert for the default host is signed

data/lib/beaker/dsl/install_utils/foss_utils.rb

@@ -245,6 +245,7 @@ module Beaker
         # @option opts [String] :puppet_agent_version Version of puppet agent to download
         # @option opts [String] :mac_download_url Url to download msi pattern of %url%/puppet-%version%.msi
         # @option opts [String] :win_download_url Url to download dmg pattern of %url%/(puppet|hiera|facter)-%version%.msi
+        # @option opts [Boolean] :run_in_parallel   Whether to install on all hosts in parallel. Defaults to false.
         #
         # @return nil
         # @raise [StandardError] When encountering an unsupported platform by default, or if gem cannot be found when default_action => 'gem_install'
@@ -257,9 +258,13 @@ module Beaker
             # backwards compatability
             opts[:puppet_agent_version] ||= opts[:version]
             install_puppet_agent_on(hosts, opts)
-
           else
-            block_on hosts do |host|
+            # Use option specified in the method call, otherwise check whether the global
+            # run_in_parallel option includes install
+            run_in_parallel = opts[:run_in_parallel]
+            run_in_parallel = ((@options && @options[:run_in_parallel].is_a?(Array)) ?
+                @options[:run_in_parallel].include?('install') : false) if run_in_parallel.nil?
+            block_on hosts, { :run_in_parallel => run_in_parallel} do |host|
               if host['platform'] =~ /el-(5|6|7)/
                 relver = $1
                 install_puppet_from_rpm_on(host, opts.merge(:release => relver, :family => 'el'))
@@ -325,6 +330,7 @@ module Beaker
         # @option opts [String] :mac_download_url Url to download msi pattern of %url%/puppet-agent-%version%.msi
         # @option opts [String] :win_download_url Url to download dmg pattern of %url%/puppet-agent-%version%.msi
         # @option opts [String] :puppet_collection Defaults to 'pc1'
+        # @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
         #
         # @return nil
         # @raise [StandardError] When encountering an unsupported platform by default, or if gem cannot be found when default_action => 'gem_install'
@@ -334,7 +340,10 @@ module Beaker
           opts[:puppet_collection] ||= 'pc1' #hi!  i'm case sensitive!  be careful!
           opts[:puppet_agent_version] ||= opts[:version] #backwards compatability with old parameter name
 
-          block_on hosts do |host|
+          run_in_parallel = opts[:run_in_parallel]
+          run_in_parallel = ((@options && @options[:run_in_parallel].is_a?(Array)) ?
+              @options[:run_in_parallel].include?('install') : false) if run_in_parallel.nil?
+          block_on hosts, { :run_in_parallel => run_in_parallel } do |host|
             add_role(host, 'aio') #we are installing agent, so we want aio role
             package_name = nil
             case host['platform']
@@ -379,6 +388,7 @@ module Beaker
         # @param [Hash{Symbol=>String}] opts
         # @option opts [Hash{String=>String}] :main configure the main section of puppet.conf
         # @option opts [Hash{String=>String}] :agent configure the agent section of puppet.conf
+        # @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
         #
         # @example will configure /etc/puppet.conf on the puppet master.
         #   config = {
@@ -407,7 +417,7 @@ module Beaker
             puppet_conf_text << "\n"
           end
           logger.debug( "setting config '#{puppet_conf_text}' on hosts #{hosts}" )
-          block_on hosts do |host|
+          block_on hosts, opts do |host|
             puppet_conf_path = host.puppet['config']
             create_remote_file(host, puppet_conf_path, puppet_conf_text)
           end

data/lib/beaker/dsl/install_utils/module_utils.rb

@@ -16,7 +16,7 @@ module Beaker
         # The directories in the module directory that will not be scp-ed to the test system when using
         # `copy_module_to`
         PUPPET_MODULE_INSTALL_IGNORE = ['.bundle', '.git', '.idea', '.vagrant', '.vendor', 'vendor', 'acceptance',
-                                        'bundle', 'spec', 'tests', 'log']
+                                        'bundle', 'spec', 'tests', 'log', '.svn', 'junit', 'pkg', 'example']
 
         # Install the desired module on all hosts using either the PMT or a
         #   staging forge

data/lib/beaker/dsl/patterns.rb

@@ -17,11 +17,13 @@ module Beaker
       #                                                as a String that can be used to search for
       #                                                a set of Hosts, or a {Host}
       #                                                or Array<{Host}> to run the block against
+      # @param [Hash{Symbol=>String}] opts Options to alter execution.
+      # @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
       # @param [Block] block This method will yield to a block of code passed by the caller
       #
       # @return [Array<Result>, Result, nil] An array of results, a result object, or nil.
       #   Check {#run_block_on} for more details on this.
-      def block_on hosts_or_filter, &block
+      def block_on hosts_or_filter, opts={}, &block
         block_hosts = nil
         if defined? hosts
           block_hosts = hosts
@@ -32,7 +34,7 @@ module Beaker
         else
           block_hosts = hosts_or_filter
         end
-        run_block_on block_hosts, filter, &block
+        run_block_on block_hosts, filter, opts, &block
       end
 
     end

data/lib/beaker/host_prebuilt_steps.rb

@@ -52,7 +52,7 @@ module Beaker
             when host['platform'] =~ /sles-/
               ntp_command = "sntp #{ntp_server}"
             else
-              ntp_command = "ntpdate -t 20 #{ntp_server}"
+              ntp_command = "ntpdate -u -t 20 #{ntp_server}"
           end
           success=false
           try = 0
@@ -71,6 +71,7 @@ module Beaker
           end
         end
       end
+      nil
     rescue => e
       report_and_raise(logger, e, "timesync (--ntp)")
     end

data/lib/beaker/hypervisor.rb

@@ -101,9 +101,10 @@ module Beaker
 
     #Default configuration steps to be run for a given hypervisor.  Any additional configuration to be done
     #to the provided SUT for test execution to be successful.
-    def configure
+    def configure(opts = {})
       return unless @options[:configure]
-      block_on @hosts do |host|
+      block_on @hosts, { :run_in_parallel => (@options && @options[:run_in_parallel].is_a?(Array)) ?
+          @options[:run_in_parallel].include?('configure') : false} do |host|
         if host[:timesync]
           timesync(host, @options)
         end

data/lib/beaker/options/presets.rb

@@ -36,6 +36,7 @@ module Beaker
         :vbguest_plugin       => ['BEAKER_VB_GUEST_PLUGIN', 'BEAKER_vb_guest_plugin'],
         :tag_includes         => ['BEAKER_TAG'],
         :tag_excludes         => ['BEAKER_EXCLUDE_TAG'],
+        :run_in_parallel      => ['BEAKER_RUN_IN_PARALLEL'],
       }
 
       # Select all environment variables whose name matches provided regex
@@ -86,6 +87,9 @@ module Beaker
 
           found_env_vars[:type] = type
         end
+        if found_env_vars[:run_in_parallel]
+          found_env_vars[:run_in_parallel] = found_env_vars[:run_in_parallel].split(',')
+        end
 
         found_env_vars[:pe_version_file_win] = found_env_vars[:pe_version_file]
         found_env_vars
@@ -188,6 +192,7 @@ module Beaker
           :nodeclassifier_port    => 4433,
           :cache_files_locally    => true, # TODO change to false in next major version
           :aws_keyname_modifier   => rand(10 ** 10).to_s.rjust(10,'0'), # 10 digit random number string
+          :run_in_parallel        => [],
           :ssh                    => {
                                      :config                => false,
                                      :paranoid              => false,

data/lib/beaker/shared/host_manager.rb

@@ -72,6 +72,8 @@ module Beaker
       #
       # @param [Array<Host>, Host] hosts The host or hosts to run the provided block against
       # @param [String, Symbol] filter Optional filter to apply to provided hosts - limits by name or role
+      # @param [Hash{Symbol=>String}] opts
+      # @option opts [Boolean] :run_in_parallel Whether to run on each host in parallel.
       # @param [Block] block This method will yield to a block of code passed by the caller
       #
       # @todo (beaker3.0:BKR-571): simplify return types to Array<Result> only
@@ -82,7 +84,7 @@ module Beaker
       #   Else, a result object is returned. If filtering makes it such that only
       #   one host is left, then it's passed as a host object (not in an array),
       #   and thus a result object is returned.
-      def run_block_on hosts = [], filter = nil, &block
+      def run_block_on hosts = [], filter = nil, opts = {}, &block
         result = nil
         block_hosts = hosts #the hosts to apply the block to after any filtering
         if filter
@@ -100,8 +102,18 @@ module Beaker
         end
         if block_hosts.is_a? Array
           if block_hosts.length > 0
-            result = block_hosts.map do |h|
-              run_block_on h, nil, &block
+            if opts[:run_in_parallel]
+              # Pass caller[1] - the line that called block_on - for logging purposes.
+              result = block_hosts.map.each_in_parallel(caller[1]) do |h|
+                run_block_on h, &block
+              end
+              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
+              result = block_hosts.map do |h|
+                run_block_on h, &block
+              end
             end
           else
             # there are no matching hosts to execute against