bolt 1.25.0 → 1.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22679235d7475d2cc80d765770e6b81b0ed0852d4563a889c00043fe61f359f1
-  data.tar.gz: a04c075cb1551ab90f6e6e9f0e6e02670b6081475a9d8f0d49fd9e7f046d0992
+  metadata.gz: 2431380225c5f60abf51caa85cfa1ee3aeadcf1ef494192e93bfb8f7e175d7f9
+  data.tar.gz: a49aa9489c0992bcaab219b54fe054dd3ef8d078231cf64ed7e039c8c580bb46
 SHA512:
-  metadata.gz: 4633d131919822b23981f8533b580e727817c95aa78a1afc05a4ca66bd14e08f3fd8f9c116f89e8726e171616c5cee1138d27260972dfc5e0718a9cb7a6096fb
-  data.tar.gz: 6a1f67bf10a65e26cd56cc9a82ad050a9023d5738b5d129cf43e203a50c1403c7cef4dd67085774dfba1d853f10174983b8e09716cc0a9d8441a24c69c62fe8b
+  metadata.gz: 2a28ce31a001a91307ce8e31cf4307a7eac3f5027143444eae22a49e406820e808bdffa668a9daad5b52bec76413af55a28c50b2aa439d4516951370d7f15210
+  data.tar.gz: fa64ecb34705bb81e728ce9067928bcde35b51630d672d8666d09766f941c26811466608f03927852061a5848135b7ee2d6725224770f0a743404a6e8840422f

data/lib/bolt/bolt_option_parser.rb

@@ -28,6 +28,9 @@ module Bolt
       when 'file'
         { flags: ACTION_OPTS + %w[tmpdir],
           banner: FILE_HELP }
+      when 'inventory'
+        { flags: OPTIONS[:inventory] + OPTIONS[:global] + %w[format inventoryfile boltdir configfile],
+          banner: INVENTORY_HELP }
       when 'plan'
         case action
         when 'convert'
@@ -110,6 +113,7 @@ Available subcommands:
   bolt secret createkeys           Create new encryption keys
   bolt secret encrypt <plaintext>  Encrypt a value
   bolt secret decrypt <encrypted>  Decrypt a value
+  bolt inventory show              Show the list of targets an action would run on
 
 Run `bolt <subcommand> --help` to view specific examples.
 
@@ -263,9 +267,19 @@ Available options are:
         createkeys               Create new encryption keys
         encrypt                  Encrypt a value
         decrypt                  Decrypt a value
+
       Available options are:
     SECRET_HELP
 
+    INVENTORY_HELP = <<~INVENTORY_HELP
+      Usage: bolt inventory <action>
+
+      Available actions are:
+        show                     Show the list of targets an action would run on
+
+      Available options are:
+    INVENTORY_HELP
+
     def initialize(options)
       super()
 
@@ -366,7 +380,8 @@ Available options are:
         @options[:'compile-concurrency'] = concurrency
       end
       define('-m', '--modulepath MODULES',
-             "List of directories containing modules, separated by '#{File::PATH_SEPARATOR}'") do |modulepath|
+             "List of directories containing modules, separated by '#{File::PATH_SEPARATOR}'",
+             'Directories are case-sensitive') do |modulepath|
         # When specified from the CLI, modulepath entries are relative to pwd
         @options[:modulepath] = modulepath.split(File::PATH_SEPARATOR).map do |moduledir|
           File.expand_path(moduledir)

data/lib/bolt/cli.rb

@@ -35,6 +35,7 @@ module Bolt
                  'file' => %w[upload],
                  'puppetfile' => %w[install show-modules],
                  'secret' => %w[encrypt decrypt createkeys],
+                 'inventory' => %w[show],
                  'apply' => %w[] }.freeze
 
     attr_reader :config, :options
@@ -117,6 +118,9 @@ module Bolt
 
       Bolt::Logger.configure(config.log, config.color)
 
+      # Logger must be configured before checking path case, otherwise warnings will not display
+      @config.check_path_case('modulepath', @config.modulepath)
+
       # After validation, initialize inventory and targets. Errors here are better to catch early.
       # After this step
       # options[:target_args] will contain a string/array version of the targetting options this is passed to plans
@@ -136,7 +140,7 @@ module Bolt
 
       options
     rescue Bolt::Error => e
-      warn e.message
+      outputter.fatal_error(e)
       raise e
     end
 
@@ -296,6 +300,8 @@ module Bolt
           else
             list_plans
           end
+        elsif options[:subcommand] == 'inventory'
+          list_targets
         end
         return 0
       elsif options[:action] == 'show-modules'
@@ -393,6 +399,11 @@ module Bolt
       outputter.print_plans(pal.list_plans, pal.list_modulepath)
     end
 
+    def list_targets
+      update_targets(options)
+      outputter.print_targets(options)
+    end
+
     def run_plan(plan_name, plan_arguments, nodes, options)
       unless nodes.empty?
         if plan_arguments['nodes']

data/lib/bolt/config.rb

@@ -286,5 +286,27 @@ module Bolt
         impl.validate(@transports[transport])
       end
     end
+
+    # Check if there is a case-insensitive match to the path
+    def check_path_case(type, paths)
+      return if paths.nil?
+      matches = matching_paths(paths)
+
+      if matches.any?
+        msg = "WARNING: Bolt is case sensitive when specifying a #{type}. Did you mean:\n"
+        matches.each { |path| msg += "         #{path}\n" }
+        @logger.warn msg
+      end
+    end
+
+    def matching_paths(paths)
+      [*paths].map { |p| Dir.glob([p, casefold(p)]) }.flatten.uniq.reject { |p| [*paths].include?(p) }
+    end
+
+    def casefold(path)
+      path.chars.map do |l|
+        l =~ /[A-Za-z]/ ? "[#{l.upcase}#{l.downcase}]" : l
+      end.join
+    end
   end
 end

data/lib/bolt/inventory/group2.rb

@@ -106,7 +106,11 @@ module Bolt
             end
             plugin.validate_inventory_config(value) if plugin.respond_to?(:validate_inventory_config)
             Concurrent::Delay.new do
-              plugin.inventory_config(value)
+              begin
+                plugin.inventory_config(value)
+              rescue StandardError => e
+                raise Bolt::Plugin::PluginError.new(e.message, plugin, "inventory_targets in #{@name}")
+              end
             end
           else
             value
@@ -203,7 +207,12 @@ module Bolt
           raise ValidationError.new("#{plugin.name} does not support inventory_targets.", @name)
         end
 
-        targets = plugin.inventory_targets(lookup)
+        begin
+          targets = plugin.inventory_targets(lookup)
+        rescue StandardError => e
+          raise Bolt::Plugin::PluginError.new(e.message, plugin, "inventory_targets in #{@name}")
+        end
+
         targets.each { |target| add_target(target) }
       end
 

data/lib/bolt/logger.rb

@@ -69,7 +69,7 @@ module Bolt
     def self.console_layout(color)
       color_scheme = :bolt if color
       Logging.layouts.pattern(
-        pattern: '%m\n',
+        pattern: '%m\e[0m\n',
         color_scheme: color_scheme
       )
     end

data/lib/bolt/outputter/human.rb

@@ -311,6 +311,13 @@ module Bolt
         end
       end
 
+      def print_targets(options)
+        targets = options[:targets].map(&:name)
+        count = "#{targets.count} target#{'s' unless targets.count == 1}"
+        @stream.puts targets.join("\n")
+        @stream.puts colorize(:green, count)
+      end
+
       # @param [Bolt::ResultSet] apply_result A ResultSet object representing the result of a `bolt apply`
       def print_apply_result(apply_result, elapsed_time)
         print_summary(apply_result, elapsed_time)

data/lib/bolt/outputter/json.rb

@@ -87,6 +87,13 @@ module Bolt
                        "moduledir": moduledir }.to_json)
       end
 
+      def print_targets(options)
+        targets = options[:targets].map(&:name)
+        count = targets.count
+        @stream.puts({ "targets": targets,
+                       "count": count }.to_json)
+      end
+
       def fatal_error(err)
         @stream.puts "],\n" if @items_open
         @stream.puts '"_error": ' if @object_open

data/lib/bolt/pal.rb

@@ -240,10 +240,14 @@ module Bolt
       end
     end
 
-    def get_task_info(task_name)
-      task = in_bolt_compiler do |compiler|
+    def task_signature(task_name)
+      in_bolt_compiler do |compiler|
         compiler.task_signature(task_name)
       end
+    end
+
+    def get_task_info(task_name)
+      task = task_signature(task_name)
 
       if task.nil?
         raise Bolt::Error.new(Bolt::Error.unknown_task(task_name), 'bolt/unknown-task')

data/lib/bolt/pal/yaml_plan.rb

@@ -48,19 +48,18 @@ module Bolt
           stringified_step = Bolt::Util.walk_keys(step) { |key| stringify(key) }
           stringified_step['name'] = stringify(stringified_step['name']) if stringified_step.key?('name')
 
-          step = Step.new(stringified_step, index + 1)
-          # Send object instead of just name so that step number is printed
-          duplicate_check(used_names, step)
+          step = Step.create(stringified_step, index + 1)
+          duplicate_check(used_names, stringified_step['name'], index + 1)
           used_names << stringified_step['name'] if stringified_step['name']
           step
         end.freeze
         @return = plan['return']
       end
 
-      def duplicate_check(used_names, step)
-        if used_names.include?(step.name)
-          error_message = "Duplicate step name or parameter detected: #{step.name.inspect}"
-          err = step.step_err_msg(error_message)
+      def duplicate_check(used_names, name, step_number)
+        if used_names.include?(name)
+          error_message = "Duplicate step name or parameter detected: #{name.inspect}"
+          err = Step.step_error(error_message, name, step_number)
           raise Bolt::Error.new(err, "bolt/invalid-plan")
         end
       end
@@ -102,6 +101,10 @@ module Bolt
         def initialize(value)
           @value = value
         end
+
+        def ==(other)
+          self.class == other.class && @value == other.value
+        end
       end
 
       # This class represents a double-quoted YAML string, which is interpreted

data/lib/bolt/pal/yaml_plan/evaluator.rb

@@ -13,23 +13,13 @@ module Bolt
         end
 
         def dispatch_step(scope, step)
-          step_type = step.type
           step_body = evaluate_code_blocks(scope, step.body)
 
-          case step_type
-          when 'task'
-            task_step(scope, step_body)
-          when 'command'
-            command_step(scope, step_body)
-          when 'plan'
-            plan_step(scope, step_body)
-          when 'script'
-            script_step(scope, step_body)
-          when 'source'
-            upload_file_step(scope, step_body)
-          when 'eval'
-            eval_step(scope, step_body)
-          end
+          # Dispatch based on the step class name
+          step_type = step.class.name.split('::').last.downcase
+          method = "#{step_type}_step"
+
+          send(method, scope, step_body)
         end
 
         def task_step(scope, step)
@@ -82,7 +72,7 @@ module Bolt
           scope.call_function('run_command', args)
         end
 
-        def upload_file_step(scope, step)
+        def upload_step(scope, step)
           source = step['source']
           destination = step['destination']
           target = step['target']
@@ -97,6 +87,51 @@ module Bolt
           step['eval']
         end
 
+        def resources_step(scope, step)
+          manifest = generate_manifest(step['resources'])
+
+          apply_manifest(scope, step['target'], manifest)
+        end
+
+        def generate_manifest(resources)
+          # inspect returns the Ruby representation of the resource hashes,
+          # which happens to be the same as the Puppet representation
+          puppet_resources = resources.inspect
+
+          # Because the :tasks setting globally controls which mode the parser
+          # is in, we need to make this snippet of non-tasks manifest code
+          # parseable in tasks mode. The way to do that is by putting it in an
+          # apply statement and taking the body.
+          <<~MANIFEST
+          apply('placeholder') {
+            $resources = #{puppet_resources}
+            $resources.each |$res| {
+              Resource[$res['type']] { $res['title']:
+                * => $res['parameters'],
+              }
+            }
+
+            # Add relationships if there is more than one resource
+            if $resources.length > 1 {
+              ($resources.length - 1).each |$index| {
+                $lhs = $resources[$index]
+                $rhs = $resources[$index+1]
+                $lhs_resource = Resource[$lhs['type'] , $lhs['title']]
+                $rhs_resource = Resource[$rhs['type'] , $rhs['title']]
+                $lhs_resource -> $rhs_resource
+              }
+            }
+          }
+          MANIFEST
+        end
+
+        def apply_manifest(scope, target, manifest)
+          ast = @evaluator.parse_string(manifest)
+          apply_block = ast.body.body
+          applicator = Puppet.lookup(:apply_executor)
+          applicator.apply([target], apply_block, scope)
+        end
+
         # This is the method that Puppet calls to evaluate the plan. The name
         # makes more sense for .pp plans.
         def evaluate_block_with_bindings(closure_scope, args_hash, plan)

data/lib/bolt/pal/yaml_plan/step.rb

@@ -8,152 +8,89 @@ module Bolt
       class Step
         attr_reader :name, :type, :body, :target
 
-        COMMON_STEP_KEYS = %w[name description target].freeze
-        STEP_KEYS = {
-          'command' => {
-            'allowed_keys' => Set['command'].merge(COMMON_STEP_KEYS),
-            'required_keys' => Set['target']
-          },
-          'script' => {
-            'allowed_keys' => Set['script', 'parameters', 'arguments'].merge(COMMON_STEP_KEYS),
-            'required_keys' => Set['target']
-          },
-          'task' => {
-            'allowed_keys' => Set['task', 'parameters'].merge(COMMON_STEP_KEYS),
-            'required_keys' => Set['target']
-          },
-          'plan' => {
-            'allowed_keys' => Set['plan', 'parameters'].merge(COMMON_STEP_KEYS),
-            'required_keys' => Set.new
-          },
-          'source' => {
-            'allowed_keys' => Set['source', 'destination'].merge(COMMON_STEP_KEYS),
-            'required_keys' => Set['target', 'source', 'destination']
-          },
-          'destination' => {
-            'allowed_keys' => Set['source', 'destination'].merge(COMMON_STEP_KEYS),
-            'required_keys' => Set['target', 'source', 'destination']
-          },
-          'eval' => {
-            'allowed_keys' => Set['eval', 'name', 'description'],
-            'required_keys' => Set.new
-          }
-        }.freeze
-
-        def initialize(step_body, step_number)
-          @body = step_body
-          @name = @body['name']
-          # For error messages
-          @step_number = step_number
-          validate_step
-
-          @type = STEP_KEYS.keys.find { |key| @body.key?(key) }
-          @target = @body['target']
+        def self.allowed_keys
+          Set['name', 'description', 'target']
         end
 
-        def transpile(plan_path)
-          result = String.new("  ")
-          result << "$#{@name} = " if @name
-
-          description = body.fetch('description', nil)
-          parameters = body.fetch('parameters', {})
-          if @type == 'script' && body.key?('arguments')
-            parameters['arguments'] = body['arguments']
-          end
-
-          case @type
-          when 'command', 'task', 'script', 'plan'
-            result << "run_#{@type}(#{Bolt::Util.to_code(body[@type])}"
-            result << ", #{Bolt::Util.to_code(@target)}" if @target
-            result << ", #{Bolt::Util.to_code(description)}" if description && type != 'plan'
-            result << ", #{Bolt::Util.to_code(parameters)}" unless parameters.empty?
-            result << ")"
-          when 'source'
-            result << "upload_file(#{Bolt::Util.to_code(body['source'])}, #{Bolt::Util.to_code(body['destination'])}"
-            result << ", #{Bolt::Util.to_code(@target)}" if @target
-            result << ", #{Bolt::Util.to_code(description)}" if description
-            result << ")"
-          when 'eval'
-            # We have to do a little extra parsing here, since we only need
-            # with() for eval blocks
-            code = Bolt::Util.to_code(body['eval'])
-            if @name && code.lines.count > 1
-              # A little indented niceness
-              indented = code.gsub(/\n/, "\n    ").chomp("  ")
-              result << "with() || {\n    #{indented}}"
+        COMMON_STEP_KEYS = %w[name description target].freeze
+        STEP_KEYS = %w[command script task plan source destination eval resources].freeze
+
+        def self.create(step_body, step_number)
+          type_keys = (STEP_KEYS & step_body.keys)
+          case type_keys.length
+          when 0
+            raise step_error("No valid action detected", step_body['name'], step_number)
+          when 1
+            type = type_keys.first
+          else
+            if type_keys.to_set == Set['source', 'destination']
+              type = 'upload'
             else
-              result << code
+              raise step_error("Multiple action keys detected: #{type_keys.inspect}", step_body['name'], step_number)
             end
-          else
-            # We should never get here
-            raise Bolt::YamlTranspiler::ConvertError.new("Can't convert unsupported step type #{@name}", plan_path)
           end
-          result << "\n"
-          result
+
+          step_class = const_get("Bolt::PAL::YamlPlan::Step::#{type.capitalize}")
+          step_class.validate(step_body, step_number)
+          step_class.new(step_body)
         end
 
-        def validate_step
-          validate_step_keys
+        def initialize(step_body)
+          @name = step_body['name']
+          @description = step_body['description']
+          @target = step_body['target']
+          @body = step_body
+        end
+
+        def transpile
+          raise NotImplementedError, "Step #{@name} does not supported conversion to Puppet plan language"
+        end
+
+        def self.validate(body, step_number)
+          validate_step_keys(body, step_number)
 
           begin
-            @body.each { |k, v| validate_puppet_code(k, v) }
+            body.each { |k, v| validate_puppet_code(k, v) }
           rescue Bolt::Error => e
-            err = step_err_msg(e.msg)
-            raise Bolt::Error.new(err, 'bolt/invalid-plan')
+            raise step_error(e.msg, body['name'], step_number)
           end
 
           unless body.fetch('parameters', {}).is_a?(Hash)
             msg = "Parameters key must be a hash"
-            raise Bolt::Error.new(step_err_msg(msg), "bolt/invalid-plan")
+            raise step_error(msg, body['name'], step_number)
           end
 
-          if @name
-            unless @name.is_a?(String) && @name.match?(Bolt::PAL::YamlPlan::VAR_NAME_PATTERN)
-              error_message = "Invalid step name: #{@name.inspect}"
-              err = step_err_msg(error_message)
-              raise Bolt::Error.new(err, "bolt/invalid-plan")
+          if body.key?('name')
+            name = body['name']
+            unless name.is_a?(String) && name.match?(Bolt::PAL::YamlPlan::VAR_NAME_PATTERN)
+              error_message = "Invalid step name: #{name.inspect}"
+              raise step_error(error_message, body['name'], step_number)
             end
           end
         end
 
-        def validate_step_keys
-          step_keys = @body.keys.to_set
-          action = step_keys.intersection(STEP_KEYS.keys.to_set).to_a
-          unless action.count == 1
-            if action.count > 1
-              # Upload step is special in that it is identified by both `source` and `destination`
-              unless action.to_set == Set['source', 'destination']
-                error_message = "Multiple action keys detected: #{action.inspect}"
-                err = step_err_msg(error_message)
-                raise Bolt::Error.new(err, "bolt/invalid-plan")
-              end
-            else
-              error_message = "No valid action detected"
-              err = step_err_msg(error_message)
-              raise Bolt::Error.new(err, "bolt/invalid-plan")
-            end
-          end
+        def self.validate_step_keys(body, step_number)
+          step_type = name.split('::').last.downcase
 
           # For validated step action, ensure only valid keys
-          unless STEP_KEYS[action.first]['allowed_keys'].superset?(step_keys)
-            illegal_keys = step_keys - STEP_KEYS[action.first]['allowed_keys']
-            error_message = "The #{action.first.inspect} step does not support: #{illegal_keys.to_a.inspect} key(s)"
-            err = step_err_msg(error_message)
+          illegal_keys = body.keys.to_set - allowed_keys
+          if illegal_keys.any?
+            error_message = "The #{step_type.inspect} step does not support: #{illegal_keys.to_a.inspect} key(s)"
+            err = step_error(error_message, body['name'], step_number)
             raise Bolt::Error.new(err, "bolt/invalid-plan")
           end
 
           # Ensure all required keys are present
-          STEP_KEYS[action.first]['required_keys'].each do |k|
-            next if step_keys.include?(k)
-            missing_keys = STEP_KEYS[action.first]['required_keys'] - step_keys
-            error_message = "The #{action.first.inspect} step requires: #{missing_keys.to_a.inspect} key(s)"
-            err = step_err_msg(error_message)
+          missing_keys = required_keys - body.keys
+          if missing_keys.any?
+            error_message = "The #{step_type.inspect} step requires: #{missing_keys.to_a.inspect} key(s)"
+            err = step_error(error_message, body['name'], step_number)
             raise Bolt::Error.new(err, "bolt/invalid-plan")
           end
         end
 
         # Recursively ensure all puppet code can be parsed
-        def validate_puppet_code(step_key, value)
+        def self.validate_puppet_code(step_key, value)
           case value
           when Array
             value.map { |element| validate_puppet_code(step_key, element) }
@@ -180,16 +117,14 @@ module Bolt
           raise Bolt::Error.new("Error parsing #{step_key.inspect}: #{e.basic_message}", "bolt/invalid-plan")
         end
 
-        def step_err_msg(message)
-          if @name
-            "Parse error in step number #{@step_number} with name #{@name.inspect}: \n #{message}"
-          else
-            "Parse error in step number #{@step_number}: \n #{message}"
-          end
+        def self.step_error(message, name, step_number)
+          identifier = name ? name.inspect : "number #{step_number}"
+          error = "Parse error in step #{identifier}: \n #{message}"
+          Bolt::Error.new(error, 'bolt/invalid-plan')
         end
 
         # Parses the an evaluable string, optionally quote it before parsing
-        def parse_code_string(code, quote = false)
+        def self.parse_code_string(code, quote = false)
           if quote
             quoted = Puppet::Pops::Parser::EvaluatingParser.quote(code)
             Puppet::Pops::Parser::EvaluatingParser.new.parse_string(quoted)
@@ -197,7 +132,20 @@ module Bolt
             Puppet::Pops::Parser::EvaluatingParser.new.parse_string(code)
           end
         end
+
+        def function_call(function, args)
+          code_args = args.map { |arg| Bolt::Util.to_code(arg) }
+          "#{function}(#{code_args.join(', ')})"
+        end
       end
     end
   end
 end
+
+require 'bolt/pal/yaml_plan/step/command'
+require 'bolt/pal/yaml_plan/step/eval'
+require 'bolt/pal/yaml_plan/step/plan'
+require 'bolt/pal/yaml_plan/step/resources'
+require 'bolt/pal/yaml_plan/step/script'
+require 'bolt/pal/yaml_plan/step/task'
+require 'bolt/pal/yaml_plan/step/upload'

data/lib/bolt/pal/yaml_plan/step/command.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Command < Step
+          def self.allowed_keys
+            super + Set['command']
+          end
+
+          def self.required_keys
+            Set['target']
+          end
+
+          def initialize(step_body)
+            super
+            @command = step_body['command']
+          end
+
+          def transpile
+            code = String.new("  ")
+            code << "$#{@name} = " if @name
+
+            fn = 'run_command'
+            args = [@command, @target]
+            args << @description if @description
+
+            code << function_call(fn, args)
+
+            code << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/step/eval.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Eval < Step
+          def self.allowed_keys
+            super + Set['eval']
+          end
+
+          def self.required_keys
+            Set.new
+          end
+
+          def initialize(step_body)
+            super
+            @eval = step_body['eval']
+          end
+
+          def transpile
+            code = String.new("  ")
+            code << "$#{@name} = " if @name
+
+            code_body = Bolt::Util.to_code(@eval)
+
+            # If we're trying to assign the result of a multi-line eval to a name
+            # variable, we need to wrap it in `with()`.
+            if @name && code_body.lines.count > 1
+              indented = code_body.gsub(/\n/, "\n    ").chomp("  ")
+              code << "with() || {\n    #{indented}}"
+            else
+              code << code_body
+            end
+
+            code << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/step/plan.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Plan < Step
+          def self.allowed_keys
+            super + Set['plan', 'parameters']
+          end
+
+          def self.required_keys
+            Set.new
+          end
+
+          def initialize(step_body)
+            super
+            @plan = step_body['plan']
+            @parameters = step_body.fetch('parameters', {})
+          end
+
+          def transpile
+            code = String.new("  ")
+            code << "$#{@name} = " if @name
+
+            fn = 'run_plan'
+            args = [@plan]
+            args << @parameters unless @parameters.empty?
+
+            code << function_call(fn, args)
+
+            code << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/step/resources.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Resources < Step
+          def self.allowed_keys
+            super + Set['resources']
+          end
+
+          def self.required_keys
+            Set['target']
+          end
+
+          def initialize(step_body)
+            super
+            @resources = step_body['resources']
+            @normalized_resources = normalize_resources(@resources)
+          end
+
+          def self.validate(body, step_number)
+            super
+
+            body['resources'].each do |resource|
+              if resource['type'] || resource['title']
+                if !resource['type']
+                  err = "Resource declaration must include type key if title key is set"
+                  raise step_error(err, body['name'], step_number)
+                elsif !resource['title']
+                  err = "Resource declaration must include title key if type key is set"
+                  raise step_error(err, body['name'], step_number)
+                end
+              else
+                type_keys = (resource.keys - ['parameters'])
+                if type_keys.empty?
+                  err = "Resource declaration is missing a type"
+                  raise step_error(err, body['name'], step_number)
+                elsif type_keys.length > 1
+                  err = "Resource declaration has ambiguous type: could be #{type_keys.join(' or ')}"
+                  raise step_error(err, body['name'], step_number)
+                end
+              end
+            end
+          end
+
+          # What if this comes from a code block?
+          def normalize_resources(resources)
+            resources.map do |resource|
+              if resource['type'] && resource['title']
+                type = resource['type']
+                title = resource['title']
+              else
+                type, = (resource.keys - ['parameters'])
+                title = resource[type]
+              end
+
+              { 'type' => type, 'title' => title, 'parameters' => resource['parameters'] || {} }
+            end
+          end
+
+          def body
+            @body.merge('resources' => @normalized_resources)
+          end
+
+          def transpile
+            code = StringIO.new
+            code.print "  "
+            code.print "$#{@name} = " if @name
+
+            code.puts "apply(#{Bolt::Util.to_code(@target)}) {"
+
+            declarations = @normalized_resources.map do |resource|
+              type = resource['type'].is_a?(EvaluableString) ? resource['type'].value : resource['type']
+              title = Bolt::Util.to_code(resource['title'])
+              parameters = Bolt::Util.map_vals(resource['parameters']) do |val|
+                Bolt::Util.to_code(val)
+              end
+
+              resource_str = StringIO.new
+              if parameters.empty?
+                resource_str.puts "    #{type} { #{title}: }"
+              else
+                resource_str.puts "    #{type} { #{title}:"
+                parameters.each do |key, val|
+                  resource_str.puts "      #{key} => #{val},"
+                end
+                resource_str.puts "    }"
+              end
+              resource_str.string
+            end
+
+            code.puts declarations.join("    ->\n")
+
+            code.puts "  }\n"
+            code.string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/step/script.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Script < Step
+          def self.allowed_keys
+            super + Set['script', 'parameters', 'arguments']
+          end
+
+          def self.required_keys
+            Set['target']
+          end
+
+          def initialize(step_body)
+            super
+            @script = step_body['script']
+            @parameters = step_body.fetch('parameters', {})
+            @arguments = step_body.fetch('arguments', [])
+          end
+
+          def transpile
+            code = String.new("  ")
+            code << "$#{@name} = " if @name
+
+            options = @parameters.dup
+            options['arguments'] = @arguments unless @arguments.empty?
+
+            fn = 'run_script'
+            args = [@script, @target]
+            args << @description if @description
+            args << options unless options.empty?
+
+            code << function_call(fn, args)
+
+            code << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/step/task.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Task < Step
+          def self.allowed_keys
+            super + Set['task', 'parameters']
+          end
+
+          def self.required_keys
+            Set['target']
+          end
+
+          def initialize(step_body)
+            super
+            @task = step_body['task']
+            @parameters = step_body.fetch('parameters', {})
+          end
+
+          def transpile
+            code = String.new("  ")
+            code << "$#{@name} = " if @name
+
+            fn = 'run_task'
+            args = [@task, @target]
+            args << @description if @description
+            args << @parameters unless @parameters.empty?
+
+            code << function_call(fn, args)
+
+            code << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/step/upload.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Bolt
+  class PAL
+    class YamlPlan
+      class Step
+        class Upload < Step
+          def self.allowed_keys
+            super + Set['source', 'destination']
+          end
+
+          def self.required_keys
+            Set['target', 'source', 'destination']
+          end
+
+          def initialize(step_body)
+            super
+            @source = step_body['source']
+            @destination = step_body['destination']
+          end
+
+          def transpile
+            code = String.new("  ")
+            code << "$#{@name} = " if @name
+
+            fn = 'upload_file'
+            args = [@source, @destination, @target]
+            args << @description if @description
+
+            code << function_call(fn, args)
+
+            code << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bolt/pal/yaml_plan/transpiler.rb

@@ -37,8 +37,7 @@ module Bolt
           plan_string << ") {\n"
 
           plan_object.steps&.each do |step|
-            # This only needs the plan path for raising errors
-            plan_string << step.transpile(@plan_path)
+            plan_string << step.transpile
           end
 
           plan_string << "\n  return #{Bolt::Util.to_code(plan_object.return)}\n" if plan_object.return

data/lib/bolt/plugin.rb

@@ -4,15 +4,24 @@ require 'bolt/plugin/puppetdb'
 require 'bolt/plugin/terraform'
 require 'bolt/plugin/pkcs7'
 require 'bolt/plugin/prompt'
+require 'bolt/plugin/task'
 
 module Bolt
   class Plugin
+    class PluginError < Bolt::Error
+      def initialize(msg, plugin, hook)
+        mess = "Error executing plugin: #{plugin.name} from #{hook}: #{msg}"
+        super(mess, 'bolt/plugin-error')
+      end
+    end
+
     def self.setup(config, pdb_client)
       plugins = new(config)
       plugins.add_plugin(Bolt::Plugin::Puppetdb.new(pdb_client))
       plugins.add_plugin(Bolt::Plugin::Terraform.new)
       plugins.add_plugin(Bolt::Plugin::Prompt.new)
       plugins.add_plugin(Bolt::Plugin::Pkcs7.new(config.boltdir.path, config.plugins['pkcs7'] || {}))
+      plugins.add_plugin(Bolt::Plugin::Task.new(config))
       plugins
     end
 

data/lib/bolt/plugin/task.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Bolt
+  class Plugin
+    class Task
+      def hooks
+        %w[inventory_targets inventory_config]
+      end
+
+      def name
+        'task'
+      end
+
+      # This creates it's own PAL so we don't have to pass a promise around
+      #
+      def initialize(config)
+        @config = config
+      end
+
+      attr_reader :config
+
+      def pal
+        # Hiera config should not be used yet.
+        @pal ||= Bolt::PAL.new(config.modulepath, config.hiera_config)
+      end
+
+      def executor
+        # Analytics should be handled at a higher level so create a new executor.
+        @executor ||= Bolt::Executor.new
+      end
+
+      def inventory
+        @inventory ||= Bolt::Inventory.new({}, config)
+      end
+
+      def run_task(opts)
+        result = pal.run_task(opts['task'],
+                              'localhost',
+                              opts['parameters'] || {},
+                              executor,
+                              inventory).first
+
+        raise Bolt::Error.new(result.error_hash['msg'], result.error_hash['kind']) if result.error_hash
+        result
+      end
+
+      def validate_options(opts)
+        raise Bolt::ValidationError, "Task plugin requires that the 'task' is specified" unless opts['task']
+
+        task = pal.task_signature(opts['task'])
+
+        raise Bolt::ValidationError, "Could not find task #{opts['task']}" unless task
+
+        errors = []
+        unless task.runnable_with?(opts['parameters'] || {}) { |msg| errors << msg }
+          # This relies on runnable with printing a partial message before the first real error
+          raise Bolt::ValidationError, "Invalid parameters for #{errors.join("\n")}"
+        end
+      end
+      alias validate_inventory_config validate_options
+
+      def inventory_config(opts)
+        result = run_task(opts)
+
+        unless result.value.include?('config')
+          raise Bolt::ValidationError, "Task result did not return 'config': #{result.value}"
+        end
+
+        result['config']
+      end
+
+      def inventory_targets(opts)
+        raise Bolt::ValidationError, "Task plugin requires that the 'task' is specified" unless opts['task']
+
+        result = run_task(opts)
+
+        targets = result['targets']
+        unless targets.is_a?(Array)
+          raise Bolt::ValidationError, "Task result did not return a targets array: #{result.value}"
+        end
+
+        unless targets.all? { |t| t.is_a?(Hash) }
+          msg = "All targets returned by an inventory targets task must be hashes, got: #{targets}"
+          raise Bolt::ValidationError, msg
+        end
+
+        targets
+      end
+    end
+  end
+end

data/lib/bolt/transport/orch.rb

@@ -22,7 +22,7 @@ module Bolt
       attr_writer :plan_context
 
       def self.options
-        %w[host service-url cacert token-file task-environment]
+        %w[host service-url cacert token-file task-environment job-poll-interval job-poll-timeout]
       end
 
       def self.default_options

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

@@ -19,7 +19,7 @@ module Bolt
         def initialize(opts, plan_context, logger)
           @logger = logger
           @key = self.class.get_key(opts)
-          client_keys = %w[service-url token-file cacert]
+          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)
           end

data/lib/bolt/version.rb

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

data/lib/bolt_server/transport_app.rb

@@ -62,11 +62,7 @@ module BoltServer
 
       task = Bolt::Task::PuppetServer.new(body['task'], @file_cache)
       parameters = body['parameters'] || {}
-      results = @executor.run_task(target, task, parameters)
-
-      # Since this will only be on one node we can just return the first result
-      result = scrub_stack_trace(results.first.status_hash)
-      [200, result.to_json]
+      @executor.run_task(target, task, parameters)
     end
 
     get '/' do
@@ -105,10 +101,13 @@ module BoltServer
         opts.delete('private-key-content')
       end
       opts['load-config'] = false
-
       target = [Bolt::Target.new(body['target']['hostname'], opts)]
 
-      method(params[:action]).call(target, body)
+      results = method(params[:action]).call(target, body)
+
+      # Since this will only be on one node we can just return the first result
+      result = scrub_stack_trace(results.first.status_hash)
+      [200, result.to_json]
     end
 
     post '/winrm/:action' do
@@ -121,10 +120,13 @@ module BoltServer
       return [400, error.to_json] unless error.nil?
 
       opts = body['target'].clone.merge('protocol' => 'winrm')
-
       target = [Bolt::Target.new(body['target']['hostname'], opts)]
 
-      method(params[:action]).call(target, body)
+      results = method(params[:action]).call(target, body)
+
+      # Since this will only be on one node we can just return the first result
+      result = scrub_stack_trace(results.first.status_hash)
+      [200, result.to_json]
     end
 
     error 404 do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.25.0
+  version: 1.26.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-27 00:00:00.000000000 Z
+date: 2019-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -386,12 +386,20 @@ files:
 - lib/bolt/pal/yaml_plan/loader.rb
 - lib/bolt/pal/yaml_plan/parameter.rb
 - lib/bolt/pal/yaml_plan/step.rb
+- lib/bolt/pal/yaml_plan/step/command.rb
+- lib/bolt/pal/yaml_plan/step/eval.rb
+- lib/bolt/pal/yaml_plan/step/plan.rb
+- lib/bolt/pal/yaml_plan/step/resources.rb
+- lib/bolt/pal/yaml_plan/step/script.rb
+- lib/bolt/pal/yaml_plan/step/task.rb
+- lib/bolt/pal/yaml_plan/step/upload.rb
 - lib/bolt/pal/yaml_plan/transpiler.rb
 - lib/bolt/plan_result.rb
 - lib/bolt/plugin.rb
 - lib/bolt/plugin/pkcs7.rb
 - lib/bolt/plugin/prompt.rb
 - lib/bolt/plugin/puppetdb.rb
+- lib/bolt/plugin/task.rb
 - lib/bolt/plugin/terraform.rb
 - lib/bolt/puppetdb.rb
 - lib/bolt/puppetdb/client.rb