bolt 3.6.1 → 3.9.0

data/bolt-modules/boltlib/lib/puppet/functions/download_file.rb

@@ -112,17 +112,13 @@ Puppet::Functions.create_function(:download_file, Puppet::Functions::InternalFun
       call_function('debug', "Simulating file download of '#{source}' - no targets given - no action taken")
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.download_file(targets, source, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.download_file(targets, source, destination, options, file_line)
             end
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.download_file(targets, source, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
+            executor.download_file(targets, source, destination, options, file_line)
           end
 
       if !r.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/parallelize.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'bolt/yarn'
-
 # Map a code block onto an array, where each array element executes in parallel.
 # This function is experimental.
 #
@@ -10,6 +8,7 @@ Puppet::Functions.create_function(:parallelize, Puppet::Functions::InternalFunct
   # Map a block onto an array, where each array element executes in parallel.
   # This function is experimental.
   # @param data The array to apply the block to.
+  # @param block The code block to execute for each array element.
   # @return [Array] An array of PlanResult objects. Each input from the input
   #   array returns a corresponding PlanResult object.
   # @example Execute two tasks on two targets.
@@ -34,21 +33,38 @@ Puppet::Functions.create_function(:parallelize, Puppet::Functions::InternalFunct
     executor = Puppet.lookup(:bolt_executor)
     executor.report_function_call(self.class.name)
 
-    skein = data.each_with_index.map do |object, index|
-      executor.create_yarn(scope, block, object, index)
-    end
+    futures = data.map do |object|
+      executor.create_future(scope: scope) do |newscope|
+        # Catch 'return' calls inside the block
+        result = catch(:return) do
+          # Add the object to the block parameters
+          args = { block.parameters[0][1].to_s => object }
+          # Execute the block. Individual plan steps in the block will yield
+          # the Fiber if they haven't finished, so all this needs to do is run
+          # the block.
+          block.closure.call_by_name_with_scope(newscope, args, true)
+        end
 
-    result = executor.round_robin(skein)
+        # If we got a return from the block, get its value
+        # Otherwise the result is the last line from the block
+        result = result.value if result.is_a?(Puppet::Pops::Evaluator::Return)
 
-    failed_indices = result.each_index.select do |i|
-      result[i].is_a?(Bolt::Error)
-    end
+        # Validate the result is a PlanResult
+        unless Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult').instance?(result)
+          raise Bolt::InvalidParallelResult.new(result.to_s, *Puppet::Pops::PuppetStack.top_of_stack)
+        end
 
-    # TODO: Inner catch errors block?
-    if failed_indices.any?
-      raise Bolt::ParallelFailure.new(result, failed_indices)
+        result
+      rescue Puppet::PreformattedError => e
+        if e.cause.is_a?(Bolt::Error)
+          e.cause
+        else
+          raise e
+        end
+      end
     end
 
-    result
+    # We may eventually want parallelize to accept a timeout
+    executor.wait(futures)
   end
 end

data/bolt-modules/boltlib/lib/puppet/functions/puppetdb_command.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Send a command with a payload to PuppetDB.
+#
+# The `pdb_command` function only supports version 5 of the `replace_facts`
+# command. Other commands might also work, but are not tested or supported
+# by Bolt.
+#
+# See the [commands endpoint](https://puppet.com/docs/puppetdb/latest/api/command/v1/commands.html)
+# documentation for more information about available commands and payload
+# format.
+#
+# _This function is experimental and subject to change._
+#
+# > **Note:** Not available in apply block
+#
+Puppet::Functions.create_function(:puppetdb_command) do
+  # @param command The command to invoke.
+  # @param version The version of the command to invoke.
+  # @param payload The payload to the command.
+  # @return The UUID identifying the response sent by PuppetDB.
+  # @example Replace facts for a target
+  #   $payload = {
+  #     'certname'           => 'localhost',
+  #     'environment'        => 'dev',
+  #     'producer'           => 'bolt',
+  #     'producer_timestamp' => '1970-01-01',
+  #     'values'             => { 'orchestrator' => 'bolt' }
+  #   }
+  #
+  #   puppetdb_command('replace_facts', 5, $payload)
+  dispatch :puppetdb_command do
+    param 'String[1]', :command
+    param 'Integer', :version
+    param 'Hash[Data, Data]', :payload
+    return_type 'String'
+  end
+
+  def puppetdb_command(command, version, payload)
+    # Disallow in apply blocks.
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
+        Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+        action: 'puppetdb_command'
+      )
+    end
+
+    # Send analytics report.
+    Puppet.lookup(:bolt_executor).report_function_call(self.class.name)
+
+    puppetdb_client = Puppet.lookup(:bolt_pdb_client)
+
+    # Error if the PDB client does not implement :send_command
+    unless puppetdb_client.respond_to?(:send_command)
+      raise Bolt::Error.new(
+        "PuppetDB client #{puppetdb_client.class} does not implement :send_command, "\
+        "unable to invoke command.",
+        'bolt/pdb-command'
+      )
+    end
+
+    puppetdb_client.send_command(command, version, payload)
+  end
+end

data/bolt-modules/boltlib/lib/puppet/functions/remove_from_group.rb

@@ -11,6 +11,7 @@ require 'bolt/error'
 Puppet::Functions.create_function(:remove_from_group) do
   # @param target A pattern identifying a single target.
   # @param group The name of the group to remove the target from.
+  # @return [nil]
   # @example Remove Target from group.
   #   remove_from_group('foo@example.com', 'group1')
   # @example Remove failing Targets from the rest of a plan

data/bolt-modules/boltlib/lib/puppet/functions/run_command.rb

@@ -87,23 +87,13 @@ Puppet::Functions.create_function(:run_command) do
       call_function('debug', "Simulating run_command('#{command}') - no targets given - no action taken")
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.run_command(targets,
-                                   command,
-                                   options,
-                                   Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.run_command(targets, command, options, file_line)
             end
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.run_command(targets,
-                                 command,
-                                 options,
-                                 Puppet::Pops::PuppetStack.top_of_stack)
+            executor.run_command(targets, command, options, file_line)
           end
 
       if !r.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/run_script.rb

@@ -108,7 +108,11 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     # Send Analytics Report
     executor.report_function_call(self.class.name)
 
-    found = Puppet::Parser::Files.find_file(script, scope.compiler.environment)
+    future = executor&.future || {}
+    fallback = future.fetch('file_paths', false)
+
+    # Find the file path if it exists, otherwise return nil
+    found = Bolt::Util.find_file_from_scope(script, scope, fallback)
     unless found && Puppet::FileSystem.exist?(found)
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, file: script
@@ -126,25 +130,13 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.run_script(targets,
-                                  found,
-                                  arguments,
-                                  options,
-                                  Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.run_script(targets, found, arguments, options, file_line)
             end
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.run_script(targets,
-                                found,
-                                arguments,
-                                options,
-                                Puppet::Pops::PuppetStack.top_of_stack)
+            executor.run_script(targets, found, arguments, options, file_line)
           end
 
       if !r.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/run_task.rb

@@ -133,25 +133,13 @@ Puppet::Functions.create_function(:run_task) do
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      result = if executor.in_parallel
-                 require 'concurrent'
-                 require 'fiber'
-                 future = Concurrent::Future.execute do
-                   executor.run_task(targets,
-                                     task,
-                                     params,
-                                     options,
-                                     Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      result = if executor.in_parallel?
+                 executor.run_in_thread do
+                   executor.run_task(targets, task, params, options, file_line)
                  end
-
-                 Fiber.yield('unfinished') while future.incomplete?
-                 future.value || future.reason
                else
-                 executor.run_task(targets,
-                                   task,
-                                   params,
-                                   options,
-                                   Puppet::Pops::PuppetStack.top_of_stack)
+                 executor.run_task(targets, task, params, options, file_line)
                end
 
       if !result.ok && !options[:catch_errors]

data/bolt-modules/boltlib/lib/puppet/functions/run_task_with.rb

@@ -180,23 +180,13 @@ Puppet::Functions.create_function(:run_task_with) do
     else
       # Combine the results from the task run with any failing results that were
       # generated earlier when creating the target mapping
-      task_result = if executor.in_parallel
-                      require 'concurrent'
-                      require 'fiber'
-                      future = Concurrent::Future.execute do
-                        executor.run_task_with(target_mapping,
-                                               task,
-                                               options,
-                                               Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      task_result = if executor.in_parallel?
+                      executor.run_in_thread do
+                        executor.run_task_with(target_mapping, task, options, file_line)
                       end
-
-                      Fiber.yield('unfinished') while future.incomplete?
-                      future.value || future.reason
                     else
-                      executor.run_task_with(target_mapping,
-                                             task,
-                                             options,
-                                             Puppet::Pops::PuppetStack.top_of_stack)
+                      executor.run_task_with(target_mapping, task, options, file_line)
                     end
       result = Bolt::ResultSet.new(task_result.results + error_set)
 

data/bolt-modules/boltlib/lib/puppet/functions/upload_file.rb

@@ -70,7 +70,11 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
     # Send Analytics Report
     executor.report_function_call(self.class.name)
 
-    found = Puppet::Parser::Files.find_file(source, scope.compiler.environment)
+    future = executor&.future || {}
+    fallback = future.fetch('file_paths', false)
+
+    # Find the file path if it exists, otherwise return nil
+    found = Bolt::Util.find_file_from_scope(source, scope, fallback)
     unless found && Puppet::FileSystem.exist?(found)
       raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
         Puppet::Pops::Issues::NO_SUCH_FILE_OR_DIRECTORY, file: source
@@ -83,25 +87,13 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
       call_function('debug', "Simulating file upload of '#{found}' - no targets given - no action taken")
       Bolt::ResultSet.new([])
     else
-      r = if executor.in_parallel
-            require 'concurrent'
-            require 'fiber'
-            future = Concurrent::Future.execute do
-              executor.upload_file(targets,
-                                   found,
-                                   destination,
-                                   options,
-                                   Puppet::Pops::PuppetStack.top_of_stack)
+      file_line = Puppet::Pops::PuppetStack.top_of_stack
+      r = if executor.in_parallel?
+            executor.run_in_thread do
+              executor.upload_file(targets, found, destination, options, file_line)
             end
-
-            Fiber.yield('unfinished') while future.incomplete?
-            future.value || future.reason
           else
-            executor.upload_file(targets,
-                                 found,
-                                 destination,
-                                 options,
-                                 Puppet::Pops::PuppetStack.top_of_stack)
+            executor.upload_file(targets, found, destination, options, file_line)
           end
       if !r.ok && !options[:catch_errors]
         raise Bolt::RunFailure.new(r, 'upload_file', source)

data/bolt-modules/boltlib/lib/puppet/functions/wait.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'bolt/logger'
+require 'bolt/target'
+
+# Wait for a Future or array of Futures to finish and return results,
+# optionally with a timeout.
+#
+# > **Note:** Not available in apply block
+Puppet::Functions.create_function(:wait, Puppet::Functions::InternalFunction) do
+  # Wait for Future(s) to finish
+  # @param futures A Bolt Future object or array of Bolt Futures to wait on.
+  # @param options A hash of additional options.
+  # @option options [Boolean] _catch_errors Whether to catch raised errors.
+  # @return A Result or Results from the Futures
+  # @example Upload a large file in the background, then wait until it's loaded
+  #   $futures = background() || {
+  #     upload_file("./very_large_file", "/opt/jfrog/artifactory/var/etc/artifactory", $targets)
+  #   }
+  #   # Run an unrelated task
+  #   run_task("deploy", $targets)
+  #   # Wait for the file upload to finish
+  #   $results = wait($futures)
+  dispatch :wait do
+    param 'Variant[Future, Array[Future]]', :futures
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'Array[Boltlib::PlanResult]'
+  end
+
+  # Wait for Future(s) to finish with timeout
+  # @param futures A Bolt Future object or array of Bolt Futures to wait on.
+  # @param timeout How long to wait for Futures to finish before raising a Timeout error.
+  # @param options A hash of additional options.
+  # @option options [Boolean] _catch_errors Whether to catch raised errors.
+  # @return A Result or Results from the Futures
+  # @example Upload a large file in the background with a 30 second timeout.
+  #   $futures = background() || {
+  #     upload_file("./very_large_file", "/opt/jfrog/artifactory/var/etc/artifactory", $targets)
+  #   }
+  #   # Run an unrelated task
+  #   run_task("deploy", $targets)
+  #   # Wait for the file upload to finish
+  #   $results = wait($futures, 30)
+  #
+  # @example Upload a large file in the background with a 30 second timeout, catching any errors.
+  #   $futures = background() || {
+  #     upload_file("./very_large_file", "/opt/jfrog/artifactory/var/etc/artifactory", $targets)
+  #   }
+  #   # Run an unrelated task
+  #   run_task("deploy", $targets)
+  #   # Wait for the file upload to finish
+  #   $results = wait($futures, 30, '_catch_errors' => true)
+  dispatch :wait_with_timeout do
+    param 'Variant[Future, Array[Future]]', :futures
+    param 'Variant[Integer[0], Float[0.0]]', :timeout
+    optional_param 'Hash[String[1], Any]', :options
+    return_type 'Array[Boltlib::PlanResult]'
+  end
+
+  def wait(futures, options = {})
+    inner_wait(futures, nil, options)
+  end
+
+  def wait_with_timeout(futures, timeout, options = {})
+    inner_wait(futures, timeout, options)
+  end
+
+  def inner_wait(futures, timeout = nil, options = {})
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'wait')
+    end
+
+    valid, unknown = options.partition { |k, _v| %w[_catch_errors].include?(k) }.map(&:to_h)
+    if unknown.any?
+      file, line = Puppet::Pops::PuppetStack.top_of_stack
+      msg = "The wait() function call in #{file}#L#{line} received unknown options "\
+        "#{unknown.keys}. Removing unknown options and continuing..."
+      Bolt::Logger.warn("plan_function_options", msg)
+    end
+
+    valid = valid.transform_keys { |k| k.sub(/^_/, '').to_sym }
+    valid[:timeout] = timeout if timeout
+
+    executor = Puppet.lookup(:bolt_executor)
+    executor.report_function_call(self.class.name)
+
+    futures = Array(futures)
+    executor.wait(futures, **valid)
+  end
+end

data/bolt-modules/boltlib/lib/puppet/functions/write_file.rb

@@ -9,6 +9,7 @@ Puppet::Functions.create_function(:write_file) do
   # @param content File content to write.
   # @param destination An absolute path on the target(s).
   # @param targets A pattern identifying zero or more targets. See {get_targets} for accepted patterns.
+  # @param options A hash of additional options.
   # @option options [Boolean] _catch_errors Whether to catch raised errors.
   # @option options [String] _run_as User to run as using privilege escalation.
   # @return A list of results, one entry per target.