bolt 2.34.0 → 2.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d33993b3430c33f173a3a2d07220d175d4545c1992e9bed3bd75a7be7bae9be
-  data.tar.gz: 68fe674fd2d8ec196149938668d68b3e4c2becd3a97639c49ee85a637bb2e5a8
+  metadata.gz: d05af3f780d500b91be547a73123d24c2da041a8ef60ba14114921358b120800
+  data.tar.gz: e8534835e69d1e5e57a353ff89a7d2667cf6d0894e8a07c1e5812282ed85b2cd
 SHA512:
-  metadata.gz: 89e8fd86df6d1427fa61df4e54b0a1973ec607bcd46744a5fa4f0316f217ae02fa0b72428527a6d3ef15303f9fae371c62954d5b53a600d4d71589a3b2108656
-  data.tar.gz: e40ee91802e4dcb6a5d542f131800b28f4916ad2245837b34f26bcef128d99485c3d96ab02e498033476fe01fe6e5740be74b985370fd390ded7b8b0683b0e04
+  metadata.gz: 97b3faac5a1e423dcebf8e4fa92f55bbc36bd1c9735fc38332db40a2bb0db0e1ddc8e1e815aa29f31f9eb3601972a8d6e07b39d0c5dc6cd2762ea87a91ddec92
+  data.tar.gz: 15963b1bb77ee04a1db4f54996964b32e599e4a0cc422dc77892151b221c1a17df9e6a1c74f160a30e9146402d48819b07b3b9d2ee9c96d7e763bba97389ccc8

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

@@ -44,9 +44,7 @@ Puppet::Functions.create_function(:catch_errors) do
       yield
     rescue Puppet::PreformattedError => e
       if e.cause.is_a?(Bolt::Error)
-        if error_types.nil?
-          e.cause.to_puppet_error
-        elsif error_types.include?(e.cause.to_h['kind'])
+        if error_types.nil? || error_types.include?(e.cause.to_h['kind'])
           e.cause.to_puppet_error
         else
           raise e

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

@@ -110,14 +110,25 @@ Puppet::Functions.create_function(:download_file, Puppet::Functions::InternalFun
     targets = inventory.get_targets(targets)
     if targets.empty?
       call_function('debug', "Simulating file download of '#{source}' - no targets given - no action taken")
-      r = Bolt::ResultSet.new([])
+      Bolt::ResultSet.new([])
     else
-      r = executor.download_file(targets, source, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
-    end
+      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)
+            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)
+          end
 
-    if !r.ok && !options[:catch_errors]
-      raise Bolt::RunFailure.new(r, 'download_file', source)
+      if !r.ok && !options[:catch_errors]
+        raise Bolt::RunFailure.new(r, 'download_file', source)
+      end
+      r
     end
-    r
   end
 end

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

@@ -0,0 +1,56 @@
+# 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.
+#
+# > **Note:** Not available in apply block.
+Puppet::Functions.create_function(:parallelize, Puppet::Functions::InternalFunction) do
+  # 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.
+  # @return [Array] An array of PlanResult objects. Each input from the input
+  #   array returns a corresponding PlanResult object.
+  # @example Execute two tasks on multiple targets. Once the task finishes on one
+  #   target, that target can move to the next step without waiting for the task
+  #   to finish on the second target.
+  # $targets = get_targets(["host1", "host2"])
+  # $result = parallelize ($targets) |$t| {
+  #   run_task('a', $t)
+  #   run_task('b', $t)
+  # }
+  dispatch :parallelize do
+    scope_param
+    param 'Array[Any]', :data
+    block_param 'Callable[Any]', :block
+    return_type 'Array[Boltlib::PlanResult]'
+  end
+
+  def parallelize(scope, data, &block)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING, action: 'parallelize')
+    end
+
+    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
+
+    result = executor.round_robin(skein)
+
+    failed_indices = result.each_index.select do |i|
+      result[i].is_a?(Bolt::Error)
+    end
+
+    # TODO: Inner catch errors block?
+    if failed_indices.any?
+      raise Bolt::ParallelFailure.new(result, failed_indices)
+    end
+
+    result
+  end
+end

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

@@ -67,14 +67,32 @@ Puppet::Functions.create_function(:run_command) do
 
     if targets.empty?
       call_function('debug', "Simulating run_command('#{command}') - no targets given - no action taken")
-      r = Bolt::ResultSet.new([])
+      Bolt::ResultSet.new([])
     else
-      r = executor.run_command(targets, command, options, Puppet::Pops::PuppetStack.top_of_stack)
-    end
+      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)
+            end
+
+            Fiber.yield('unfinished') while future.incomplete?
+            future.value || future.reason
+          else
+            executor.run_command(targets,
+                                 command,
+                                 options,
+                                 Puppet::Pops::PuppetStack.top_of_stack)
+          end
+
+      if !r.ok && !options[:catch_errors]
+        raise Bolt::RunFailure.new(r, 'run_command', command)
+      end
 
-    if !r.ok && !options[:catch_errors]
-      raise Bolt::RunFailure.new(r, 'run_command', command)
+      r
     end
-    r
   end
 end

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

@@ -84,15 +84,34 @@ Puppet::Functions.create_function(:run_script, Puppet::Functions::InternalFuncti
     # Ensure that given targets are all Target instances)
     targets = inventory.get_targets(targets)
 
-    r = if targets.empty?
-          Bolt::ResultSet.new([])
-        else
-          executor.run_script(targets, found, arguments, options, Puppet::Pops::PuppetStack.top_of_stack)
-        end
+    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)
+            end
 
-    if !r.ok && !options[:catch_errors]
-      raise Bolt::RunFailure.new(r, 'run_script', script)
+            Fiber.yield('unfinished') while future.incomplete?
+            future.value || future.reason
+          else
+            executor.run_script(targets,
+                                found,
+                                arguments,
+                                options,
+                                Puppet::Pops::PuppetStack.top_of_stack)
+          end
+
+      if !r.ok && !options[:catch_errors]
+        raise Bolt::RunFailure.new(r, 'run_script', script)
+      end
+      r
     end
-    r
   end
 end

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

@@ -133,7 +133,27 @@ Puppet::Functions.create_function(:run_task) do
     if targets.empty?
       Bolt::ResultSet.new([])
     else
-      result = executor.run_task(targets, task, params, options, Puppet::Pops::PuppetStack.top_of_stack)
+      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)
+                 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)
+               end
+
       if !result.ok && !options[:catch_errors]
         raise Bolt::RunFailure.new(result, 'run_task', task_name)
       end

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

@@ -180,7 +180,24 @@ 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 = executor.run_task_with(target_mapping, task, options, Puppet::Pops::PuppetStack.top_of_stack)
+      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)
+                      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)
+                    end
       result = Bolt::ResultSet.new(task_result.results + error_set)
 
       if !result.ok && !options[:catch_errors]

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

@@ -81,14 +81,32 @@ Puppet::Functions.create_function(:upload_file, Puppet::Functions::InternalFunct
     targets = inventory.get_targets(targets)
     if targets.empty?
       call_function('debug', "Simulating file upload of '#{found}' - no targets given - no action taken")
-      r = Bolt::ResultSet.new([])
+      Bolt::ResultSet.new([])
     else
-      r = executor.upload_file(targets, found, destination, options, Puppet::Pops::PuppetStack.top_of_stack)
-    end
+      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)
+            end
 
-    if !r.ok && !options[:catch_errors]
-      raise Bolt::RunFailure.new(r, 'upload_file', source)
+            Fiber.yield('unfinished') while future.incomplete?
+            future.value || future.reason
+          else
+            executor.upload_file(targets,
+                                 found,
+                                 destination,
+                                 options,
+                                 Puppet::Pops::PuppetStack.top_of_stack)
+          end
+      if !r.ok && !options[:catch_errors]
+        raise Bolt::RunFailure.new(r, 'upload_file', source)
+      end
+      r
     end
-    r
   end
 end

data/lib/bolt/cli.rb

@@ -575,10 +575,15 @@ module Bolt
       outputter.print_task_info(pal.get_task(task_name))
     end
 
+    # Filters a list of content by matching substring.
+    #
+    private def filter_content(content, filter)
+      return content unless content && filter
+      content.select { |name,| name.include?(filter) }
+    end
+
     def list_tasks
-      tasks = pal.list_tasks
-      tasks.select! { |task| task.first.include?(options[:filter]) } if options[:filter]
-      tasks.select! { |task| config.project.tasks.include?(task.first) } unless config.project.tasks.nil?
+      tasks = filter_content(pal.list_tasks(filter_content: true), options[:filter])
       outputter.print_tasks(tasks, pal.user_modulepath)
     end
 
@@ -587,9 +592,7 @@ module Bolt
     end
 
     def list_plans
-      plans = pal.list_plans
-      plans.select! { |plan| plan.first.include?(options[:filter]) } if options[:filter]
-      plans.select! { |plan| config.project.plans.include?(plan.first) } unless config.project.plans.nil?
+      plans = filter_content(pal.list_plans(filter_content: true), options[:filter])
       outputter.print_plans(plans, pal.user_modulepath)
     end
 

data/lib/bolt/config/options.rb

@@ -283,7 +283,7 @@ module Bolt
           _example: "myproject"
         },
         "plans" => {
-          description: "A list of plan names to show in `bolt plan show` output, if they exist. This option is used "\
+          description: "A list of plan names and glob patterns to filter the project's plans by. This option is used "\
                        "to limit the visibility of plans for users of the project. For example, project authors "\
                        "might want to limit the visibility of plans that are bundled with Bolt or plans that should "\
                        "only be run as part of another plan. When this option is not configured, all plans are "\
@@ -291,7 +291,7 @@ module Bolt
                        "list.",
           type: Array,
           _plugin: false,
-          _example: ["myproject", "myproject::foo", "myproject::bar"]
+          _example: ["myproject", "myproject::foo", "myproject::bar", "myproject::deploy::*"]
         },
         "plugin_hooks" => {
           description: "A map of [plugin hooks](writing_plugins.md#hooks) and which plugins a hook should use. "\
@@ -402,7 +402,7 @@ module Bolt
           _default: true
         },
         "tasks" => {
-          description: "A list of task names to show in `bolt task show` output, if they exist. This option is used "\
+          description: "A list of task names and glob patterns to filter the project's tasks by. This option is used "\
                        "to limit the visibility of tasks for users of the project. For example, project authors "\
                        "might want to limit the visibility of tasks that are bundled with Bolt or plans that should "\
                        "only be run as part of a larger workflow. When this option is not configured, all tasks "\
@@ -413,7 +413,7 @@ module Bolt
             type: String
           },
           _plugin: false,
-          _example: ["myproject", "myproject::foo", "myproject::bar"]
+          _example: ["myproject", "myproject::foo", "myproject::bar", "myproject::deploy_*"]
         },
         "trusted-external-command" => {
           description: "The path to an executable on the Bolt controller that can produce external trusted facts. "\

data/lib/bolt/config/transport/options.rb

@@ -357,7 +357,7 @@ module Bolt
             description: "The URL of the host used for API requests.",
             format: "uri",
             _plugin: true,
-            _example: "https://api.example.com:<port>"
+            _example: "https://api.example.com:8143"
           },
           "shell-command" => {
             type: String,

data/lib/bolt/error.rb

@@ -90,6 +90,20 @@ module Bolt
     end
   end
 
+  class ParallelFailure < Bolt::Error
+    def initialize(results, failed_indices)
+      details = {
+        'action' => 'parallelize',
+        'failed_indices' => failed_indices,
+        'results' => results
+      }
+      message = "Plan aborted: parallel block failed on #{failed_indices.length} target"
+      message += "s" unless failed_indices.length == 1
+      super(message, 'bolt/parallel-failure', details)
+      @error_code = 2
+    end
+  end
+
   class PlanFailure < Error
     def initialize(*args)
       super(*args)
@@ -131,6 +145,16 @@ module Bolt
     end
   end
 
+  class InvalidParallelResult < Error
+    def initialize(result_str, file, line)
+      super("Parallel block returned an invalid result: #{result_str}",
+            'bolt/invalid-plan-result',
+            { 'file' => file,
+              'line' => line,
+              'result_string' => result_str })
+    end
+  end
+
   class ValidationError < Bolt::Error
     def initialize(msg)
       super(msg, 'bolt/validation-error')

data/lib/bolt/executor.rb

@@ -17,6 +17,7 @@ require 'bolt/transport/orch'
 require 'bolt/transport/local'
 require 'bolt/transport/docker'
 require 'bolt/transport/remote'
+require 'bolt/yarn'
 
 module Bolt
   TRANSPORTS = {
@@ -29,7 +30,7 @@ module Bolt
   }.freeze
 
   class Executor
-    attr_reader :noop, :transports
+    attr_reader :noop, :transports, :in_parallel
     attr_accessor :run_as
 
     def initialize(concurrency = 1,
@@ -60,6 +61,7 @@ module Bolt
 
       @noop = noop
       @run_as = nil
+      @in_parallel = false
       @pool = if concurrency > 0
                 Concurrent::ThreadPoolExecutor.new(name: 'exec', max_threads: concurrency)
               else
@@ -84,6 +86,14 @@ module Bolt
       self
     end
 
+    def unsubscribe(subscriber, types = nil)
+      if types.nil? || types.sort == @subscribers[subscriber]&.sort
+        @subscribers.delete(subscriber)
+      elsif @subscribers[subscriber].is_a?(Array)
+        @subscribers[subscriber] = @subscribers[subscriber] - types
+      end
+    end
+
     def publish_event(event)
       @subscribers.each do |subscriber, types|
         # If types isn't set or if the subscriber is subscribed to
@@ -359,6 +369,82 @@ module Bolt
       plan.call_by_name_with_scope(scope, params, true)
     end
 
+    def create_yarn(scope, block, object, index)
+      fiber = Fiber.new do
+        # Create the new scope
+        newscope = Puppet::Parser::Scope.new(scope.compiler)
+        local = Puppet::Parser::Scope::LocalScope.new
+
+        # Compress the current scopes into a single vars hash to add to the new scope
+        current_scope = scope.effective_symtable(true)
+        until current_scope.nil?
+          current_scope.instance_variable_get(:@symbols)&.each_pair { |k, v| local[k] = v }
+          current_scope = current_scope.parent
+        end
+        newscope.push_ephemerals([local])
+
+        begin
+          result = catch(:return) do
+            args = { block.parameters[0][1].to_s => object }
+            block.closure.call_by_name_with_scope(newscope, args, true)
+          end
+
+          # If we got a return from the block, get it's value
+          # Otherwise the result is the last line from the block
+          result = result.value if result.is_a?(Puppet::Pops::Evaluator::Return)
+
+          # 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
+
+          result
+        rescue Puppet::PreformattedError => e
+          if e.cause.is_a?(Bolt::Error)
+            e.cause
+          else
+            raise e
+          end
+        end
+      end
+
+      Bolt::Yarn.new(fiber, index)
+    end
+
+    def handle_event(event)
+      case event[:type]
+      when :node_result
+        @thread_completed = true
+      end
+    end
+
+    def round_robin(skein)
+      subscribe(self, [:node_result])
+      results = Array.new(skein.length)
+      @in_parallel = true
+
+      until skein.empty?
+        @thread_completed = false
+        r = nil
+
+        skein.each do |yarn|
+          if yarn.alive?
+            r = yarn.resume
+          else
+            results[yarn.index] = yarn.value
+            skein.delete(yarn)
+          end
+        end
+
+        next unless r == 'unfinished'
+        sleep(0.1) until @thread_completed || skein.empty?
+      end
+
+      @in_parallel = false
+      unsubscribe(self, [:node_result])
+      results
+    end
+
     class TimeoutError < RuntimeError; end
 
     def wait_until_available(targets,

data/lib/bolt/outputter/human.rb

@@ -215,7 +215,7 @@ module Bolt
 
       def print_tasks(tasks, modulepath)
         command = Bolt::Util.powershell? ? 'Get-BoltTask -Task <TASK NAME>' : 'bolt task show <TASK NAME>'
-        print_table(tasks)
+        tasks.any? ? print_table(tasks) : print_message('No available tasks')
         print_message("\nMODULEPATH:\n#{modulepath.join(File::PATH_SEPARATOR)}\n"\
                         "\nUse '#{command}' to view "\
                         "details and parameters for a specific task.")
@@ -299,7 +299,7 @@ module Bolt
 
       def print_plans(plans, modulepath)
         command = Bolt::Util.powershell? ? 'Get-BoltPlan -Name <PLAN NAME>' : 'bolt plan show <PLAN NAME>'
-        print_table(plans)
+        plans.any? ? print_table(plans) : print_message('No available plans')
         print_message("\nMODULEPATH:\n#{modulepath.join(File::PATH_SEPARATOR)}\n"\
                         "\nUse '#{command}' to view "\
                         "details and parameters for a specific plan.")

data/lib/bolt/pal.rb

@@ -26,7 +26,7 @@ module Bolt
         details[:line]   = err.line if defined?(err.line)
         details[:column] = err.pos if defined?(err.pos)
 
-        error.add_filelineno(details)
+        error.add_filelineno(details.compact)
         error
       end
 
@@ -286,15 +286,26 @@ module Bolt
       raise Bolt::PAL::PALError, "Failed to parse manifest: #{e}"
     end
 
-    def list_tasks
+    # Filters content by a list of names and glob patterns specified in project
+    # configuration.
+    def filter_content(content, patterns)
+      return content unless content && patterns
+
+      content.select do |name,|
+        patterns.any? { |pattern| File.fnmatch?(pattern, name, File::FNM_EXTGLOB) }
+      end
+    end
+
+    def list_tasks(filter_content: false)
       in_bolt_compiler do |compiler|
-        tasks = compiler.list_tasks
-        tasks.map(&:name).sort.each_with_object([]) do |task_name, data|
+        tasks = compiler.list_tasks.map(&:name).sort.each_with_object([]) do |task_name, data|
           task_sig = compiler.task_signature(task_name)
           unless task_sig.task_hash['metadata']['private']
             data << [task_name, task_sig.task_hash['metadata']['description']]
           end
         end
+
+        filter_content ? filter_content(tasks, @project&.tasks) : tasks
       end
     end
 
@@ -346,14 +357,15 @@ module Bolt
       Bolt::Task.from_task_signature(task)
     end
 
-    def list_plans
+    def list_plans(filter_content: false)
       in_bolt_compiler do |compiler|
         errors = []
         plans = compiler.list_plans(nil, errors).map { |plan| [plan.name] }.sort
         errors.each do |error|
           @logger.warn(error.details['original_error'])
         end
-        plans
+
+        filter_content ? filter_content(plans, @project&.plans) : plans
       end
     end
 

data/lib/bolt/pal/yaml_plan.rb

@@ -45,6 +45,13 @@ module Bolt
         used_names = Set.new(@parameters.map(&:name))
 
         @steps = plan['steps'].each_with_index.map do |step, index|
+          unless step.is_a?(Hash)
+            raise Bolt::Error.new(
+              "Parse error in step number #{index + 1}: Plan step must be an object with valid step keys.",
+              'bolt/invalid-plan'
+            )
+          end
+
           # Step keys also aren't allowed to be code and neither is the value of "name"
           stringified_step = Bolt::Util.walk_keys(step) { |key| stringify(key) }
           stringified_step['name'] = stringify(stringified_step['name']) if stringified_step.key?('name')

data/lib/bolt/puppetdb/client.rb

@@ -2,7 +2,6 @@
 
 require 'json'
 require 'logging'
-require 'uri'
 
 module Bolt
   module PuppetDB
@@ -108,13 +107,15 @@ module Bolt
       end
 
       def uri
+        require 'addressable/uri'
+
         @current_url ||= (@config.server_urls - @bad_urls).first
         unless @current_url
           msg = "Failed to connect to all PuppetDB server_urls: #{@config.server_urls.to_a.join(', ')}."
           raise Bolt::PuppetDBError, msg
         end
 
-        uri = URI.parse(@current_url)
+        uri = Addressable::URI.parse(@current_url)
         uri.port ||= 8081
         uri
       end

data/lib/bolt/puppetdb/config.rb

@@ -89,6 +89,8 @@ module Bolt
 
       def uri
         return @uri if @uri
+        require 'addressable/uri'
+
         uri = case @settings['server_urls']
               when String
                 @settings['server_urls']
@@ -100,7 +102,7 @@ module Bolt
                 raise Bolt::PuppetDBError, "server_urls must be a string or array"
               end
 
-        @uri = URI.parse(uri)
+        @uri = Addressable::URI.parse(uri)
         @uri.port ||= 8081
         @uri
       end

data/lib/bolt/transport/orch.rb

@@ -10,11 +10,6 @@ require 'bolt/transport/orch/connection'
 module Bolt
   module Transport
     class Orch < Base
-      CONF_FILE = if ENV['HOME'].nil?
-                    '/etc/puppetlabs/client-tools/orchestrator.conf'
-                  else
-                    File.expand_path('~/.puppetlabs/client-tools/orchestrator.conf')
-                  end
       BOLT_COMMAND_TASK = Struct.new(:name).new('bolt_shim::command').freeze
       BOLT_SCRIPT_TASK = Struct.new(:name).new('bolt_shim::script').freeze
       BOLT_UPLOAD_TASK = Struct.new(:name).new('bolt_shim::upload').freeze

data/lib/bolt/transport/orch/connection.rb

@@ -17,13 +17,20 @@ module Bolt
         end
 
         def initialize(opts, plan_context, logger)
+          require 'addressable/uri'
+
           @logger = logger
           @key = self.class.get_key(opts)
-          client_keys = %w[service-url token-file cacert job-poll-interval job-poll-timeout]
-          client_opts = client_keys.each_with_object({}) do |k, acc|
-            acc[k] = opts[k] if opts.include?(k)
+          client_opts = opts.slice('token-file', 'cacert', 'job-poll-interval', 'job-poll-timeout')
+
+          if opts['service-url']
+            uri = Addressable::URI.parse(opts['service-url'])
+            uri&.port ||= 8143
+            client_opts['service-url'] = uri.to_s
           end
+
           client_opts['User-Agent'] = "Bolt/#{VERSION}"
+
           %w[token-file cacert].each do |f|
             client_opts[f] = File.expand_path(client_opts[f]) if client_opts[f]
           end

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '2.34.0'
+  VERSION = '2.35.0'
 end

data/lib/bolt/yarn.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+module Bolt
+  class Yarn
+    attr_reader :fiber, :value, :index
+
+    def initialize(fiber, index)
+      @fiber = fiber
+      @index = index
+      @value = nil
+    end
+
+    def alive?
+      fiber.alive?
+    end
+
+    def resume
+      @value = fiber.resume
+    end
+  end
+end

data/lib/bolt_server/transport_app.rb

@@ -48,6 +48,10 @@ module BoltServer
     # See the `orchestrator.bolt.codedir` tk config setting.
     DEFAULT_BOLT_CODEDIR = '/opt/puppetlabs/server/data/orchestration-services/code'
 
+    MISSING_PROJECT_REF_RESPONSE = [
+      400, Bolt::ValidationError.new('`project_ref` is a required argument').to_json
+    ].freeze
+
     def initialize(config)
       @config = config
       @schemas = Hash[REQUEST_SCHEMAS.map do |basename|
@@ -261,13 +265,16 @@ module BoltServer
       end
     end
 
-    def in_bolt_project(bolt_project)
-      return [400, '`project_ref` is a required argument'] if bolt_project.nil?
-      project_dir = File.join(@config['projects-dir'], bolt_project)
-      return [400, "`project_ref`: #{project_dir} does not exist"] unless Dir.exist?(project_dir)
+    def config_from_project(project_ref)
+      project_dir = File.join(@config['projects-dir'], project_ref)
+      raise Bolt::ValidationError, "`project_ref`: #{project_dir} does not exist" unless Dir.exist?(project_dir)
+      project = Bolt::Project.create_project(project_dir)
+      Bolt::Config.from_project(project, { log: { 'bolt-debug.log' => 'disable' } })
+    end
+
+    def in_bolt_project(project_ref)
       @pal_mutex.synchronize do
-        project = Bolt::Project.create_project(project_dir)
-        bolt_config = Bolt::Config.from_project(project, { log: { 'bolt-debug.log' => 'disable' } })
+        bolt_config = config_from_project(project_ref)
         modulepath_object = Bolt::Config::Modulepath.new(
           bolt_config.modulepath,
           boltlib_path: [PE_BOLTLIB_PATH, Bolt::Config::Modulepath::BOLTLIB_PATH]
@@ -508,6 +515,7 @@ module BoltServer
     #
     # @param project_ref [String] the project to fetch the plan from
     get '/project_plans/:module_name/:plan_name' do
+      return MISSING_PROJECT_REF_RESPONSE if params['project_ref'].nil?
       in_bolt_project(params['project_ref']) do |context|
         plan_info = pe_plan_info(context[:pal], params[:module_name], params[:plan_name])
         plan_info = allowed_helper(plan_info, context[:config].project.plans)
@@ -532,6 +540,7 @@ module BoltServer
     #
     # @param bolt_project_ref [String] the reference to the bolt-project directory to load task metadata from
     get '/project_tasks/:module_name/:task_name' do
+      return MISSING_PROJECT_REF_RESPONSE if params['project_ref'].nil?
       in_bolt_project(params['project_ref']) do |context|
         ps_parameters = {
           'project' => params['project_ref']
@@ -570,6 +579,7 @@ module BoltServer
     #
     # @param project_ref [String] the project to fetch the list of plans from
     get '/project_plans' do
+      return MISSING_PROJECT_REF_RESPONSE if params['project_ref'].nil?
       in_bolt_project(params['project_ref']) do |context|
         plans_response = plan_list(context[:pal])
 
@@ -603,6 +613,7 @@ module BoltServer
     #
     # @param project_ref [String] the project to fetch the list of tasks from
     get '/project_tasks' do
+      return MISSING_PROJECT_REF_RESPONSE if params['project_ref'].nil?
       in_bolt_project(params['project_ref']) do |context|
         tasks_response = task_list(context[:pal])
 
@@ -621,6 +632,7 @@ module BoltServer
     #
     # @param project_ref [String] the project_ref to fetch the file metadatas from
     get '/project_file_metadatas/:module_name/*' do
+      return MISSING_PROJECT_REF_RESPONSE if params['project_ref'].nil?
       in_bolt_project(params['project_ref']) do |context|
         file = params[:splat].first
         metadatas = file_metadatas(context[:pal], params[:module_name], file)
@@ -630,13 +642,32 @@ module BoltServer
       [400, e.message]
     end
 
+    # Returns a list of targets parsed from a Project inventory
+    #
+    # @param project_ref [String] the project_ref to compute the inventory from
+    get '/project_inventory_targets' do
+      return MISSING_PROJECT_REF_RESPONSE if params['project_ref'].nil?
+      bolt_config = config_from_project(params['project_ref'])
+      if bolt_config.inventoryfile && bolt_config.project.inventory_file.to_s != bolt_config.inventoryfile
+        raise Bolt::ValidationError, "Project inventory must be defined in the " \
+          "inventory.yaml file at the root of the project directory"
+      end
+      plugins = Bolt::Plugin.setup(bolt_config, nil)
+      inventory = Bolt::Inventory.from_config(bolt_config, plugins)
+      target_list = inventory.get_targets('all').map { |targ| targ.to_h.merge({ 'transport' => targ.transport }) }
+
+      [200, target_list.to_json]
+    rescue Bolt::Error => e
+      [500, e.to_json]
+    end
+
     error 404 do
       err = Bolt::Error.new("Could not find route #{request.path}",
                             'boltserver/not-found')
       [404, err.to_json]
     end
 
-    error 500 do
+    error StandardError do
       e = env['sinatra.error']
       err = Bolt::Error.new("500: Unknown error: #{e.message}",
                             'boltserver/server-error')

data/lib/bolt_spec/plans/mock_executor.rb

@@ -17,12 +17,13 @@ module BoltSpec
 
     # Nothing on the executor is 'public'
     class MockExecutor
-      attr_reader :noop, :error_message
+      attr_reader :noop, :error_message, :in_parallel
       attr_accessor :run_as, :transport_features, :execute_any_plan
 
       def initialize(modulepath)
         @noop = false
         @run_as = nil
+        @in_parallel = false
         @error_message = nil
         @allow_apply = false
         @modulepath = [modulepath].flatten.map { |path| File.absolute_path(path) }
@@ -133,6 +134,7 @@ module BoltSpec
         # through to another conditional statement
         doub = @plan_doubles[plan_name] || @plan_doubles[:default]
 
+        # rubocop:disable Lint/DuplicateBranch
         # High level:
         #  - If we've explicitly allowed execution of the plan (normally the main plan
         #    passed into BoltSpec::Plan::run_plan()), then execute it
@@ -165,6 +167,7 @@ module BoltSpec
           @error_message = "Unexpected call to 'run_plan(#{plan_name}, #{params_str})'"
           raise UnexpectedInvocation, @error_message
         end
+        # rubocop:enable Lint/DuplicateBranch
         result
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 2.34.0
+  version: 2.35.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-10 00:00:00.000000000 Z
+date: 2020-11-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -404,6 +404,7 @@ files:
 - bolt-modules/boltlib/lib/puppet/functions/get_resources.rb
 - bolt-modules/boltlib/lib/puppet/functions/get_target.rb
 - bolt-modules/boltlib/lib/puppet/functions/get_targets.rb
+- bolt-modules/boltlib/lib/puppet/functions/parallelize.rb
 - bolt-modules/boltlib/lib/puppet/functions/puppetdb_fact.rb
 - bolt-modules/boltlib/lib/puppet/functions/puppetdb_query.rb
 - bolt-modules/boltlib/lib/puppet/functions/remove_from_group.rb
@@ -555,6 +556,7 @@ files:
 - lib/bolt/util.rb
 - lib/bolt/util/puppet_log_level.rb
 - lib/bolt/version.rb
+- lib/bolt/yarn.rb
 - lib/bolt_server/acl.rb
 - lib/bolt_server/base_config.rb
 - lib/bolt_server/config.rb