beaker-pe 3.6.4 → 3.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17f39948dbc58217035cd4e93469070ac5f35309dc2078fb3995e7edc6558d7f
-  data.tar.gz: 65d1131709c2e886a82dc29f74a7f5a9907f89b2da0fc799233f325954069193
+  metadata.gz: 330fb055e63900ac5bdefd9d48a122eb35a13872c6a820bb072fe88409415ab7
+  data.tar.gz: 17588df9d4e67e74cab914118a35457d66aad62397c6c1194c41eb1ba51e967c
 SHA512:
-  metadata.gz: bef219e4d18d83b1663764cb203cdeb1f857a889d602e4b22d91e1a47c9d96019a169bc8265cf67d485f3082bd67704e7454bc2caf5dff8548bf333be7fcda23
-  data.tar.gz: 420a8f53c44f65636413a31b292b8f510369a740fa619c9c163143e4af02f0de115c7fca9c9bae7cf29d4a63a94a103cf8fd8d26cc4048e6202a4292a1194248
+  metadata.gz: 50576aa57b1e28945226720abe0f959cf1c05b56c29e84f61a215b461bb171728b27c0b03eaea233b9da69fc948938536c23ee8057bc7c54f5647c1ef6d6fd94
+  data.tar.gz: 8e5c488e4dbfd2a940f78a7bf434efc5d9fac63ffece679e07d5a078a616c807c480fe234b53d3710bc0b67c447362382abecefa25e14139f5762ba2195bd0b9

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [3.6.5](https://github.com/puppetlabs/beaker-pe/tree/3.6.5) (2026-07-29)
+
+[Full Changelog](https://github.com/puppetlabs/beaker-pe/compare/3.6.4...3.6.5)
+
+**Implemented enhancements:**
+
+- (PE-45366) Add pe_run_in_parallel option, serial by default on macOS [#309](https://github.com/puppetlabs/beaker-pe/pull/309) ([Magisus](https://github.com/Magisus))
+
 ## [3.6.4](https://github.com/puppetlabs/beaker-pe/tree/3.6.4) (2026-07-23)
 
 [Full Changelog](https://github.com/puppetlabs/beaker-pe/compare/3.6.3...3.6.4)

data/README.md

@@ -31,6 +31,27 @@ of key concepts.
 involved in addressing key problems and use-cases. For instance, checkout our
 [How-to Install Puppet Enterprise doc](docs/how_to/install_puppet_enterprise.md).
 
+## Configuration
+
+### Running install/upgrade steps serially (`pe_run_in_parallel`)
+
+Several PE install/upgrade steps act on many hosts at once by `fork()`ing a child
+process per host, each with its own SSH connection. **On macOS, forking a Ruby
+process that has already used `Net::SSH` deadlocks the child**, so these steps hang
+until beaker's watchdog kills them (`RuntimeError: Child process ran longer than
+timeout of 1800`). This does not happen on Linux/CI.
+
+Because of this, beaker-pe defaults to running these steps **serially on macOS** and
+**in parallel on every other platform**. You can override the default either way:
+
+- Option: set `pe_run_in_parallel: true` (or `false`) in your beaker options.
+- Env var: `export BEAKER_PE_RUN_IN_PARALLEL=1` (or `0`) before running beaker.
+
+Precedence, highest first: the `BEAKER_PE_RUN_IN_PARALLEL` env var, then the
+`pe_run_in_parallel` option, then the platform default (`false` on macOS, `true`
+elsewhere). For the env var, `1`, `true`, or `yes` force parallel; `0`, `false`, or
+`no` force serial.
+
 ## Upgrading from 0.y to 1.y?
 
 If you've used beaker-pe previously (during the 0.y versions), you'll

data/lib/beaker-pe/install/pe_utils.rb

@@ -1519,12 +1519,27 @@ NOASK
             (host['platform'] =~ /windows-2008r2/ && (!version_is_less(host['pe_ver'], '2016.4.99') && version_is_less(host['pe_ver'], '2016.5.99') && !version_is_less(host['pe_ver'], '3.99')))
         end
 
+        # Whether PE install/upgrade steps that act on many hosts should fork and
+        # run in parallel. Forking + Net::SSH deadlocks on macOS, so the default is
+        # serial there and parallel everywhere else; a developer can override either
+        # way. Precedence, highest first:
+        #   BEAKER_PE_RUN_IN_PARALLEL env var > :pe_run_in_parallel option > default
+        #   (false on macOS, true elsewhere)
+        # @api private
+        # @return [Boolean]
+        def pe_run_in_parallel?
+          env = ENV['BEAKER_PE_RUN_IN_PARALLEL']
+          return %w[1 true yes].include?(env.downcase) unless env.nil? || env.empty?
+          opt = options[:pe_run_in_parallel]
+          opt.nil? ? (RUBY_PLATFORM !~ /darwin/) : !!opt
+        end
+
         # Runs puppet on all nodes, unless they have the roles: master,database,console/dashboard
         # @param [Array<Host>] hosts The sorted hosts to install or upgrade PE on
         def run_puppet_on_non_infrastructure_nodes(all_hosts)
           pe_infrastructure = select_hosts({:roles => ['master', 'compile_master', 'pe_compiler', 'dashboard', 'database']}, all_hosts)
           non_infrastructure = all_hosts.reject{|host| pe_infrastructure.include? host}
-          on non_infrastructure, puppet_agent('-t'), :acceptable_exit_codes => [0,2], :run_in_parallel => true
+          on non_infrastructure, puppet_agent('-t'), :acceptable_exit_codes => [0,2], :run_in_parallel => pe_run_in_parallel?
         end
 
         # Whether or not PE should be managing the puppet service on agents.
@@ -2133,7 +2148,7 @@ EOM
           end
 
           step "Stop agent service on infrastructure nodes" do
-            stop_agent_on(pe_infrastructure, :run_in_parallel => true)
+            stop_agent_on(pe_infrastructure, :run_in_parallel => pe_run_in_parallel?)
           end
 
           # waitforlock in case stopping the agent run after stopping the agent service
@@ -2488,7 +2503,7 @@ EOM
             end
 
              step "Install agents" do
-               block_on(agent_nodes, {:run_in_parallel => true}) do |host|
+               block_on(agent_nodes, {:run_in_parallel => pe_run_in_parallel?}) do |host|
                  install_ca_cert_on(host, opts)
                  on(host, installer_cmd(host, opts))
                end
@@ -2500,13 +2515,13 @@ EOM
              end
 
              step "Stop puppet agents to avoid interfering with tests" do
-               stop_agent_on(agent_nodes, :run_in_parallel => true)
+               stop_agent_on(agent_nodes, :run_in_parallel => pe_run_in_parallel?)
              end
 
              # waitforlock in case stopping the agent run after stopping the agent service
              # takes a little longer than usual
              step "Run puppet on all agent nodes" do
-               block_on(agent_nodes, {:run_in_parallel => true}) do |host|
+               block_on(agent_nodes, {:run_in_parallel => pe_run_in_parallel?}) do |host|
                  on host, puppet_agent("-t #{waitforlock_flag(host)}"), :acceptable_exit_codes => [0,2]
                end
              end

data/lib/beaker-pe/version.rb

@@ -3,7 +3,7 @@ module Beaker
     module PE
 
       module Version
-        STRING = '3.6.4'
+        STRING = '3.6.5'
       end
 
     end

data/spec/beaker-pe/install/pe_utils_spec.rb

@@ -25,6 +25,17 @@ class ClassMixedWithDSLInstallUtils
 end
 
 describe ClassMixedWithDSLInstallUtils do
+  # Neutralize BEAKER_PE_RUN_IN_PARALLEL and pin RUBY_PLATFORM to a non-macOS value
+  # for every example in this file, so that pre-existing specs asserting the default
+  # (:run_in_parallel => true) are not affected by whatever a developer happens to
+  # have exported in their shell or by running the suite on a Mac (where the default
+  # is serial). Examples that exercise the macOS default stub RUBY_PLATFORM to darwin.
+  before do
+    allow(ENV).to receive(:[]).and_call_original
+    allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return(nil)
+    stub_const('RUBY_PLATFORM', 'x86_64-linux')
+  end
+
   let(:presets)       { Beaker::Options::Presets.new }
   let(:opts)          { presets.presets.merge(presets.env_vars) }
   let(:basic_hosts)   { make_hosts( { :pe_ver => '3.0',
@@ -612,6 +623,35 @@ describe ClassMixedWithDSLInstallUtils do
     end
   end
 
+  describe '#run_puppet_on_non_infrastructure_nodes parallel wiring' do
+    let(:master)   { make_host('master', :pe_ver => '2016.4', :platform => 'el-7-x86_64', :roles => ['master', 'database', 'dashboard']) }
+    let(:el_agent) { make_host('agent', :pe_ver => '2016.4', :platform => 'el-7-x86_64', :roles => ['frictionless']) }
+
+    before do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return(nil)
+    end
+
+    it 'passes run_in_parallel => false when the option disables it' do
+      subject.options[:pe_run_in_parallel] = false
+      expect(subject).to receive(:on).with(
+        [el_agent],
+        anything,
+        hash_including(:run_in_parallel => false)
+      ).once
+      subject.run_puppet_on_non_infrastructure_nodes([master, el_agent])
+    end
+
+    it 'passes run_in_parallel => true by default' do
+      expect(subject).to receive(:on).with(
+        [el_agent],
+        anything,
+        hash_including(:run_in_parallel => true)
+      ).once
+      subject.run_puppet_on_non_infrastructure_nodes([master, el_agent])
+    end
+  end
+
   describe 'install_via_msi?' do
     it 'returns true if pe_version is before PE 2016.4.0' do
       the_host = winhost.dup
@@ -661,6 +701,71 @@ describe ClassMixedWithDSLInstallUtils do
 
   end
 
+  describe '#pe_run_in_parallel?' do
+    before do
+      # Default: pretend the env var is unset unless a specific example sets it.
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return(nil)
+    end
+
+    context 'with no option and no env var' do
+      it 'defaults to true off macOS' do
+        stub_const('RUBY_PLATFORM', 'x86_64-linux')
+        expect(subject.send(:pe_run_in_parallel?)).to eq(true)
+      end
+
+      it 'defaults to false on macOS' do
+        stub_const('RUBY_PLATFORM', 'x86_64-darwin21')
+        expect(subject.send(:pe_run_in_parallel?)).to eq(false)
+      end
+    end
+
+    context 'with the :pe_run_in_parallel option' do
+      it 'returns false when the option is false' do
+        subject.options[:pe_run_in_parallel] = false
+        expect(subject.send(:pe_run_in_parallel?)).to eq(false)
+      end
+
+      it 'returns true when the option is true' do
+        subject.options[:pe_run_in_parallel] = true
+        expect(subject.send(:pe_run_in_parallel?)).to eq(true)
+      end
+    end
+
+    context 'with the BEAKER_PE_RUN_IN_PARALLEL env var set' do
+      %w[1 true yes TRUE Yes].each do |truthy|
+        it "returns true for #{truthy.inspect}" do
+          allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return(truthy)
+          expect(subject.send(:pe_run_in_parallel?)).to eq(true)
+        end
+      end
+
+      %w[0 false no off].each do |falsey|
+        it "returns false for #{falsey.inspect}" do
+          allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return(falsey)
+          expect(subject.send(:pe_run_in_parallel?)).to eq(false)
+        end
+      end
+
+      it 'overrides the option (env true beats option false)' do
+        subject.options[:pe_run_in_parallel] = false
+        allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return('1')
+        expect(subject.send(:pe_run_in_parallel?)).to eq(true)
+      end
+
+      it 'overrides the option (env false beats option true)' do
+        subject.options[:pe_run_in_parallel] = true
+        allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return('0')
+        expect(subject.send(:pe_run_in_parallel?)).to eq(false)
+      end
+
+      it 'falls through to the default when the env var is empty' do
+        allow(ENV).to receive(:[]).with('BEAKER_PE_RUN_IN_PARALLEL').and_return('')
+        expect(subject.send(:pe_run_in_parallel?)).to eq(true)
+      end
+    end
+  end
+
   describe 'higgs installer' do
     let(:host) { unixhost }
     let(:higgs_regex) { %r{cd .* ; nohup \./puppet-enterprise-installer <<<#{higgs_answer} .*} }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: beaker-pe
 version: !ruby/object:Gem::Version
-  version: 3.6.4
+  version: 3.6.5
 platform: ruby
 authors:
 - Puppetlabs