bolt 1.17.0 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9fe11fc4842de35277e098cfe7740eb274df8aa5a6e1049cab373c31d196612
-  data.tar.gz: 7884fb6bbc0292e0545a9429ba134dc3bbcb5045d86b924391cdafb523eba1f9
+  metadata.gz: aa6e4eb68e71946db22097bb174c21cfd49be4541980b8e0690a52e72a7a9330
+  data.tar.gz: 6e8cc701adcc4c3351e907e9d8550844bb014e3ab96d92afdca2115ed1b9ca41
 SHA512:
-  metadata.gz: 8a9a4298796b099efb223ae4a9277a2a6b589f1f8d27267af0de768494579aa820bc3191338cb6eaa73c0f8a23112c48bef2e2037d5dea72d3b3d5204a0bb4ce
-  data.tar.gz: 89c4a471a4b4c23e71cc1fb25df7fcd29e5b76374eb63564deca6b6a113c7c5c0c052d461c0277f668c1b5c8be644d3796c3de2f5078ce0127e32d4090591ec4
+  metadata.gz: 6f7a793488438e0fb03700c536e1dbd680604eed52ea51ae03d1d7aa4da55203be5f4bb19bd481aceef92d0cbd30d531adf3e139a8cb36b9706e33afc249fe4f
+  data.tar.gz: a16943eac6c51d4e06df6bba47b81786053c3c1127ce26c3bbb5308ac88459c789ff3a327c24b192794f7e0c42222e5354b25faa4b8564d52e8bd1a7605b1abb

data/lib/bolt/bolt_option_parser.rb

@@ -135,17 +135,23 @@ Usage: bolt apply <manifest.pp> [options]
       @options = options
 
       @nodes = define('-n', '--nodes NODES',
-                      'Identifies the nodes to target.',
-                      'Enter a comma-separated list of node URIs or group names.',
-                      "Or read a node list from an input file '@<file>' or stdin '-'.",
-                      'Example: --nodes localhost,node_group,ssh://nix.com:23,winrm://windows.puppet.com',
-                      'URI format is [protocol://]host[:port]',
-                      "SSH is the default protocol; may be #{TRANSPORTS.keys.join(', ')}",
-                      'For Windows nodes, specify the winrm:// protocol if it has not be configured',
-                      'For SSH, port defaults to `22`',
-                      'For WinRM, port defaults to `5985` or `5986` based on the --[no-]ssl setting') do |nodes|
+                      'Alias for --targets') do |nodes|
+        @options [:nodes] ||= []
         @options[:nodes] << get_arg_input(nodes)
       end.extend(SwitchHider)
+      @targets = define('-t', '--targets TARGETS',
+                        'Identifies the targets of command.',
+                        'Enter a comma-separated list of target URIs or group names.',
+                        "Or read a target list from an input file '@<file>' or stdin '-'.",
+                        'Example: --targets localhost,node_group,ssh://nix.com:23,winrm://windows.puppet.com',
+                        'URI format is [protocol://]host[:port]',
+                        "SSH is the default protocol; may be #{TRANSPORTS.keys.join(', ')}",
+                        'For Windows targets, specify the winrm:// protocol if it has not be configured',
+                        'For SSH, port defaults to `22`',
+                        'For WinRM, port defaults to `5985` or `5986` based on the --[no-]ssl setting') do |targets|
+        @options[:targets] ||= []
+        @options[:targets] << get_arg_input(targets)
+      end.extend(SwitchHider)
       @query = define('-q', '--query QUERY', 'Query PuppetDB to determine the targets') do |query|
         @options[:query] = query
       end.extend(SwitchHider)
@@ -290,9 +296,13 @@ Usage: bolt apply <manifest.pp> [options]
       update
     end
 
+    def hide_target_opts(toggle = true)
+      @nodes.hide = @query.hide = @rerun.hide = @targets.hide = toggle
+    end
+
     def update
       # show the --nodes, --query, and --rerun switches by default
-      @nodes.hide = @query.hide = @rerun.hide = false
+      hide_target_opts(false)
       # Don't show the --execute switch except for `apply`
       @execute.hide = true
 
@@ -310,7 +320,7 @@ Usage: bolt apply <manifest.pp> [options]
                       FILE_HELP
                     when 'puppetfile'
                       # Don't show targeting options for puppetfile
-                      @nodes.hide = @query.hide = @rerun.hide = true
+                      hide_target_opts
                       PUPPETFILE_HELP
                     when 'apply'
                       @execute.hide = false

data/lib/bolt/cli.rb

@@ -19,6 +19,7 @@ require 'bolt/rerun'
 require 'bolt/logger'
 require 'bolt/outputter'
 require 'bolt/puppetdb'
+require 'bolt/plugin'
 require 'bolt/pal'
 require 'bolt/target'
 require 'bolt/version'
@@ -41,14 +42,12 @@ module Bolt
       @logger = Logging.logger[self]
       @argv = argv
       @config = Bolt::Config.default
-      @options = {
-        nodes: []
-      }
+      @options = {}
     end
 
     # Only call after @config has been initialized.
     def inventory
-      @inventory ||= Bolt::Inventory.from_config(config)
+      @inventory ||= Bolt::Inventory.from_config(config, plugins)
     end
     private :inventory
 
@@ -117,8 +116,11 @@ module Bolt
       Bolt::Logger.configure(config.log, config.color)
 
       # 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
+      # options[:targets] will contain a resolved set of Target objects
       unless options[:subcommand] == 'puppetfile' || options[:action] == 'show'
-        options[:targets] = get_targets(options)
+        update_targets(options)
       end
 
       options
@@ -127,23 +129,24 @@ module Bolt
       raise e
     end
 
-    def get_targets(options)
-      target_opts =  options.keys.select { |opt| %i[query rerun].include?(opt) }
-      target_opts << :nodes unless options[:nodes].empty?
+    def update_targets(options)
+      target_opts = options.keys.select { |opt| %i[query rerun nodes targets].include?(opt) }
+      target_string = "'--nodes', '--targets', '--rerun', or '--query'"
       if target_opts.length > 1
-        raise Bolt::CLIError, "Only one of '--nodes', '--rerun', or '--query' may be specified"
+        raise Bolt::CLIError, "Only one targeting option #{target_string} may be specified"
+      elsif target_opts.empty? && options[:subcommand] != 'plan'
+        raise Bolt::CLIError, "Command requires a targeting option: #{target_string}"
       end
 
-      if options[:query]
-        nodes = query_puppetdb_nodes(options[:query])
-        options[:nodes] = nodes if options[:subcommand] == 'plan'
-      elsif options[:rerun]
-        nodes = rerun.get_targets(options[:rerun])
-        options[:nodes] = nodes if options[:subcommand] == 'plan'
-      else
-        nodes = options[:nodes]
-      end
-      inventory.get_targets(nodes)
+      nodes = if options[:query]
+                query_puppetdb_nodes(options[:query])
+              elsif options[:rerun]
+                rerun.get_targets(options[:rerun])
+              else
+                options[:targets] || options[:nodes] || []
+              end
+      options[:target_args] = nodes
+      options[:targets] = inventory.get_targets(nodes)
     end
 
     def validate(options)
@@ -184,14 +187,6 @@ module Bolt
         end
       end
 
-      if !%w[plan puppetfile].include?(options[:subcommand]) && options[:action] != 'show'
-        if options[:nodes].empty? && options[:query].nil? && options[:rerun].nil?
-          raise Bolt::CLIError, "Targets must be specified with '--nodes', '--query' or '--rerun'"
-        elsif options[:nodes].any? && options[:query]
-          raise Bolt::CLIError, "Only one of '--nodes', '--query', or '--rerun'  may be specified"
-        end
-      end
-
       if options[:boltdir] && options[:configfile]
         raise Bolt::CLIError, "Only one of '--boltdir' or '--configfile' may be specified"
       end
@@ -227,6 +222,10 @@ module Bolt
       @puppetdb_client = Bolt::PuppetDB::Client.new(puppetdb_config)
     end
 
+    def plugins
+      @plugins ||= Bolt::Plugin.setup(config, puppetdb_client)
+    end
+
     def query_puppetdb_nodes(query)
       puppetdb_client.query_certnames(query)
     end
@@ -284,7 +283,7 @@ module Bolt
 
       case options[:subcommand]
       when 'plan'
-        code = run_plan(options[:object], options[:task_options], options[:nodes], options)
+        code = run_plan(options[:object], options[:task_options], options[:target_args], options)
       when 'puppetfile'
         code = install_puppetfile(@config.puppetfile, @config.modulepath)
       when 'apply'

data/lib/bolt/inventory.rb

@@ -43,7 +43,7 @@ module Bolt
       end
     end
 
-    def self.from_config(config)
+    def self.from_config(config, plugins = nil)
       if ENV.include?(ENVIRONMENT_VAR)
         begin
           data = YAML.safe_load(ENV[ENVIRONMENT_VAR])
@@ -54,18 +54,18 @@ module Bolt
         data = Bolt::Util.read_config_file(config.inventoryfile, config.default_inventoryfile, 'inventory')
       end
 
-      inventory = create_version(data, config)
+      inventory = create_version(data, config, plugins)
       inventory.validate
       inventory
     end
 
-    def self.create_version(data, config)
+    def self.create_version(data, config, plugins)
       version = (data || {}).delete('version') { 1 }
       case version
       when 1
         new(data, config)
       when 2
-        Bolt::Inventory::Inventory2.new(data, config)
+        Bolt::Inventory::Inventory2.new(data, config, plugins: plugins)
       else
         raise ValidationError, "Unsupported version #{version} specified in inventory"
       end

data/lib/bolt/inventory/group2.rb

@@ -13,7 +13,7 @@ module Bolt
 
       DATA_KEYS = %w[name config facts vars features].freeze
       NODE_KEYS = DATA_KEYS + %w[alias uri]
-      GROUP_KEYS = DATA_KEYS + %w[groups targets]
+      GROUP_KEYS = DATA_KEYS + %w[groups targets target-lookups]
       CONFIG_KEYS = Bolt::TRANSPORTS.keys.map(&:to_s) + ['transport']
 
       def initialize(data)
@@ -36,6 +36,8 @@ module Bolt
         @features = fetch_value(data, 'features', Array)
         @config = fetch_value(data, 'config', Hash)
 
+        @target_lookups = fetch_value(data, 'target-lookups', Array)
+
         unless (unexpected_keys = @config.keys - CONFIG_KEYS).empty?
           msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for group #{@name}"
           @logger.warn(msg)
@@ -46,58 +48,18 @@ module Bolt
 
         @targets = {}
         @aliases = {}
-        targets.reject { |target| target.is_a?(String) }.each do |target|
-          unless target.is_a?(Hash)
-            raise ValidationError.new("Node entry must be a String or Hash, not #{target.class}", @name)
-          end
-
-          target['name'] ||= target['uri']
-
-          if target['name'].nil? || target['name'].empty?
-            raise ValidationError.new("No name or uri for target: #{target}", @name)
-          end
-
-          if @targets.include?(target['name'])
-            @logger.warn("Ignoring duplicate target in #{@name}: #{target}")
-            next
-          end
-
-          raise ValidationError.new("Node #{target} does not have a name", @name) unless target['name']
-          @targets[target['name']] = target
-
-          unless (unexpected_keys = target.keys - NODE_KEYS).empty?
-            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in target #{target['name']}"
-            @logger.warn(msg)
-          end
-          config_keys = target['config']&.keys || []
-          unless (unexpected_keys = config_keys - CONFIG_KEYS).empty?
-            msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for target #{target['name']}"
-            @logger.warn(msg)
-          end
-
-          next unless target.include?('alias')
-
-          aliases = target['alias']
-          aliases = [aliases] if aliases.is_a?(String)
-          unless aliases.is_a?(Array)
-            msg = "Alias entry on #{target['name']} must be a String or Array, not #{aliases.class}"
-            raise ValidationError.new(msg, @name)
-          end
-
-          aliases.each do |alia|
-            raise ValidationError.new("Invalid alias #{alia}", @name) unless alia =~ NAME_REGEX
-
-            if (found = @aliases[alia])
-              raise ValidationError.new(alias_conflict(alia, found, target['name']), @name)
-            end
-            @aliases[alia] = target['name']
+        @name_or_alias = []
+        targets.each do |target|
+          # If target is a string, it can refer to either a target name or
+          # alias. Which can't be determined until all groups have been
+          # resolved, and requires a depth-first traversal to categorize them.
+          if target.is_a?(String)
+            @name_or_alias << target
+          else
+            add_target(target)
           end
         end
 
-        # If target is a string, it can refer to either a target name or alias. Which can't be determined
-        # until all groups have been resolved, and requires a depth-first traversal to categorize them.
-        @name_or_alias = targets.select { |target| target.is_a?(String) }
-
         @groups = groups.map { |g| Group2.new(g) }
       end
 
@@ -115,6 +77,79 @@ module Bolt
         end
       end
 
+      def add_target(target)
+        # TODO: Do we want to accept strings from lookup_targets plugins? How should
+        # they be handled?
+        unless target.is_a?(Hash)
+          raise ValidationError.new("Node entry must be a String or Hash, not #{target.class}", @name)
+        end
+
+        target['name'] ||= target['uri']
+
+        if target['name'].nil? || target['name'].empty?
+          raise ValidationError.new("No name or uri for target: #{target}", @name)
+        end
+
+        if @targets.include?(target['name'])
+          @logger.warn("Ignoring duplicate target in #{@name}: #{target}")
+          return
+        end
+
+        raise ValidationError.new("Node #{target} does not have a name", @name) unless target['name']
+        @targets[target['name']] = target
+
+        unless (unexpected_keys = target.keys - NODE_KEYS).empty?
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in target #{target['name']}"
+          @logger.warn(msg)
+        end
+        config_keys = target['config']&.keys || []
+        unless (unexpected_keys = config_keys - CONFIG_KEYS).empty?
+          msg = "Found unexpected key(s) #{unexpected_keys.join(', ')} in config for target #{target['name']}"
+          @logger.warn(msg)
+        end
+
+        unless target.include?('alias')
+          return
+        end
+
+        aliases = target['alias']
+        aliases = [aliases] if aliases.is_a?(String)
+        unless aliases.is_a?(Array)
+          msg = "Alias entry on #{target['name']} must be a String or Array, not #{aliases.class}"
+          raise ValidationError.new(msg, @name)
+        end
+
+        aliases.each do |alia|
+          raise ValidationError.new("Invalid alias #{alia}", @name) unless alia =~ NAME_REGEX
+
+          if (found = @aliases[alia])
+            raise ValidationError.new(alias_conflict(alia, found, target['name']), @name)
+          end
+          @aliases[alia] = target['name']
+        end
+      end
+
+      def lookup_targets(plugins)
+        @target_lookups.each do |lookup|
+          unless lookup.is_a?(Hash)
+            raise ValidationError.new("target-lookup is not a hash: #{lookup}", @name)
+          end
+          unless lookup['plugin']
+            raise ValidationError.new("target-lookup does not specify a plugin: #{lookup}", @name)
+          end
+
+          unless (plugin = plugins.by_name(lookup['plugin']))
+            raise ValidationError.new("target-lookup specifies an unkown plugin: '#{lookup['plugin']}'", @name)
+
+          end
+
+          targets = plugin.lookup_targets(lookup)
+          targets.each { |target| add_target(target) }
+        end
+
+        @groups.each { |g| g.lookup_targets(plugins) }
+      end
+
       def data_merge(data1, data2)
         if data2.nil? || data1.nil?
           return data2 || data1

data/lib/bolt/inventory/inventory2.rb

@@ -12,7 +12,7 @@ module Bolt
         end
       end
 
-      def initialize(data, config = nil, target_vars: {}, target_facts: {}, target_features: {})
+      def initialize(data, config = nil, plugins: nil, target_vars: {}, target_facts: {}, target_features: {})
         @logger = Logging.logger[self]
         # Config is saved to add config options to targets
         @config = config || Bolt::Config.default
@@ -23,6 +23,7 @@ module Bolt
         @target_facts = target_facts
         @target_features = target_features
 
+        @groups.lookup_targets(plugins)
         @groups.resolve_aliases(@groups.target_aliases, @groups.target_names)
         collect_groups
       end

data/lib/bolt/pal/yaml_plan.rb

@@ -3,6 +3,40 @@
 module Bolt
   class PAL
     class YamlPlan
+      PLAN_KEYS = Set['parameters', 'steps', 'return', 'version']
+      PARAMETER_KEYS = Set['type', 'default', 'description']
+      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
+
       Parameter = Struct.new(:name, :value, :type_expr) do
         def captures_rest
           false
@@ -15,16 +49,35 @@ module Bolt
         # Top-level plan keys aren't allowed to be Puppet code, so force them
         # all to strings.
         plan = Bolt::Util.walk_keys(plan) { |key| stringify(key) }
-
         @name = name.freeze
 
         # Nothing in parameters is allowed to be code, since no variables are defined yet
         params_hash = stringify(plan.fetch('parameters', {}))
 
+        # Ensure params is a hash
+        unless params_hash.is_a?(Hash)
+          raise Bolt::Error.new("Plan parameters must be a Hash", "bolt/invalid-plan")
+        end
+
+        # Validate top level plan keys
+        top_level_keys = plan.keys.to_set
+        unless PLAN_KEYS.superset?(top_level_keys)
+          invalid_keys = top_level_keys - PLAN_KEYS
+          raise Bolt::Error.new("Plan contains illegal key(s) #{invalid_keys.to_a.inspect}",
+                                "bolt/invalid-plan")
+        end
+
         # Munge parameters into an array of Parameter objects, which is what
         # the Puppet API expects
         @parameters = params_hash.map do |param, definition|
           definition ||= {}
+          definition_keys = definition.keys.to_set
+          unless PARAMETER_KEYS.superset?(definition_keys)
+            invalid_keys = definition_keys - PARAMETER_KEYS
+            raise Bolt::Error.new("Plan parameter #{param.inspect} contains illegal key(s)" \
+                                  " #{invalid_keys.to_a.inspect}",
+                                  "bolt/invalid-plan")
+          end
           type = Puppet::Pops::Types::TypeParser.singleton.parse(definition['type']) if definition.key?('type')
           Parameter.new(param, definition['default'], type)
         end.freeze
@@ -49,6 +102,7 @@ module Bolt
         end
 
         used_names = Set.new
+        step_number = 1
 
         # Parameters come in a hash, so they must be unique
         @parameters.each do |param|
@@ -60,18 +114,28 @@ module Bolt
         end
 
         @steps.each do |step|
-          next unless step.key?('name')
+          validate_step_keys(step, step_number)
 
-          unless step['name'].is_a?(String) && step['name'].match?(VAR_NAME_PATTERN)
-            raise Bolt::Error.new("Invalid step name #{step['name'].inspect}", "bolt/invalid-plan")
+          begin
+            step.each { |k, v| validate_puppet_code(k, v) }
+          rescue Bolt::Error => e
+            raise Bolt::Error.new(step_err_msg(step_number, step['name'], e.msg), 'bolt/invalid-plan')
           end
 
-          if used_names.include?(step['name'])
-            msg = "Step name #{step['name'].inspect} matches an existing parameter or step name"
-            raise Bolt::Error.new(msg, "bolt/invalid-plan")
-          end
+          if step.key?('name')
+            unless step['name'].is_a?(String) && step['name'].match?(VAR_NAME_PATTERN)
+              error_message = "Invalid step name: #{step['name'].inspect}"
+              raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
+            end
+
+            if used_names.include?(step['name'])
+              error_message = "Duplicate step name or parameter detected: #{step['name'].inspect}"
+              raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
+            end
 
-          used_names << step['name']
+            used_names << step['name']
+          end
+          step_number += 1
         end
       end
 
@@ -103,6 +167,84 @@ module Bolt
         Puppet::Pops::Types::TypeParser.singleton.parse('Boltlib::PlanResult')
       end
 
+      def step_err_msg(step_number, step_name, message)
+        if step_name
+          "Parse error in step number #{step_number} with name #{step_name.inspect}: \n #{message}"
+        else
+          "Parse error in step number #{step_number}: \n #{message}"
+        end
+      end
+
+      def validate_step_keys(step, step_number)
+        step_keys = step.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}"
+              raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
+            end
+          else
+            error_message = "No valid action detected"
+            raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
+          end
+        end
+
+        # 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)"
+          raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "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)"
+          raise Bolt::Error.new(step_err_msg(step_number, step['name'], error_message), "bolt/invalid-plan")
+        end
+      end
+
+      # Recursively ensure all puppet code can be parsed
+      def validate_puppet_code(step_key, value)
+        case value
+        when Array
+          value.map { |element| validate_puppet_code(step_key, element) }
+        when Hash
+          value.each_with_object({}) do |(k, v), o|
+            key = k.is_a?(EvaluableString) ? k.value : k
+            o[key] = validate_puppet_code(key, v)
+          end
+        # CodeLiterals can be parsed directly
+        when CodeLiteral
+          parse_code_string(value.value)
+        # BareString is parsed directly if it starts with '$'
+        when BareString
+          if value.value.start_with?('$')
+            parse_code_string(value.value)
+          else
+            parse_code_string(value.value, true)
+          end
+        when EvaluableString
+          # Must quote parsed strings to evaluate them
+          parse_code_string(value.value, true)
+        end
+      rescue Puppet::Error => e
+        raise Bolt::Error.new("Error parsing #{step_key.inspect}: #{e.basic_message}", "bolt/invalid-plan")
+      end
+
+      # Parses the an evaluable string, optionally quote it before parsing
+      def parse_code_string(code, quote = false)
+        if quote
+          quoted = Puppet::Pops::Parser::EvaluatingParser.quote(code)
+          Puppet::Pops::Parser::EvaluatingParser.new.parse_string(quoted)
+        else
+          Puppet::Pops::Parser::EvaluatingParser.new.parse_string(code)
+        end
+      end
+
       # This class wraps a value parsed from YAML which may be Puppet code.
       # That includes double-quoted strings and string literals, each of which
       # subclasses this parent class in order to implement its own evaluation

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

@@ -17,10 +17,7 @@ module Bolt
         def dispatch_step(scope, step)
           step = evaluate_code_blocks(scope, step)
 
-          step_type, *extra_keys = STEP_KEYS.select { |key| step.key?(key) }
-          if !step_type || extra_keys.any?
-            unsupported_step(scope, step)
-          end
+          step_type = STEP_KEYS.find { |key| step.key?(key) }
 
           case step_type
           when 'task'
@@ -35,11 +32,6 @@ module Bolt
             upload_file_step(scope, step)
           when 'eval'
             eval_step(scope, step)
-          else
-            # This shouldn't be able to happen since this case statement should
-            # match the STEP_KEYS list, but raise an error *just in case*,
-            # instead of silently skipping the step.
-            unsupported_step(scope, step)
           end
         end
 
@@ -48,7 +40,6 @@ module Bolt
           target = step['target']
           description = step['description']
           params = step['parameters'] || {}
-          raise "Can't run a task without specifying a target" unless target
 
           args = if description
                    [task, target, description, params]
@@ -73,7 +64,6 @@ module Bolt
           target = step['target']
           description = step['description']
           arguments = step['arguments'] || []
-          raise "Can't run a script without specifying a target" unless target
 
           options = { 'arguments' => arguments }
           args = if description
@@ -89,7 +79,6 @@ module Bolt
           command = step['command']
           target = step['target']
           description = step['description']
-          raise "Can't run a command without specifying a target" unless target
 
           args = [command, target]
           args << description if description
@@ -101,8 +90,6 @@ module Bolt
           destination = step['destination']
           target = step['target']
           description = step['description']
-          raise "Can't upload a file without specifying a target" unless target
-          raise "Can't upload a file without specifying a destination" unless destination
 
           args = [source, destination, target]
           args << description if description
@@ -113,10 +100,6 @@ module Bolt
           step['eval']
         end
 
-        def unsupported_step(_scope, step)
-          raise Bolt::Error.new("Unsupported plan step", "bolt/unsupported-step", step: step)
-        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/plugin.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bolt/plugin/puppetdb'
+
+module Bolt
+  class Plugin
+    def self.setup(config, pdb_client)
+      plugins = new(config)
+      plugins.add_plugin(Bolt::Plugin::Puppetdb.new(pdb_client))
+      plugins
+    end
+
+    def initialize(_config)
+      @plugins = {}
+    end
+
+    def add_plugin(plugin)
+      @plugins[plugin.name] = plugin
+    end
+
+    def for_hook(hook)
+      @plugins.filter { |_n, plug| plug.hooks.include? hook }
+    end
+
+    def by_name(plugin_name)
+      @plugins[plugin_name]
+    end
+  end
+end

data/lib/bolt/plugin/puppetdb.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Bolt
+  class Plugin
+    class Puppetdb
+      def initialize(pdb_client)
+        @puppetdb_client = pdb_client
+      end
+
+      def name
+        'puppetdb'
+      end
+
+      def hooks
+        ['lookup_targets']
+      end
+
+      def lookup_targets(opts)
+        nodes = @puppetdb_client.query_certnames(opts['query'])
+        nodes.map { |certname| { 'uri' => certname } }
+      end
+    end
+  end
+end

data/lib/bolt/rerun.rb

@@ -46,6 +46,7 @@ module Bolt
 
         if result_set.is_a?(Bolt::ResultSet)
           data = result_set.map { |res| res.status_hash.select { |k, _| %i[target status].include? k } }
+          FileUtils.mkdir_p(File.dirname(@path))
           File.write(@path, data.to_json)
         elsif File.exist?(@path)
           FileUtils.rm(@path)

data/lib/bolt/transport/sudoable.rb

@@ -44,7 +44,7 @@ module Bolt
               conn.copy_file(source, tmpfile)
               # pass over file ownership if we're using run-as to be a different user
               dir.chown(conn.run_as)
-              result = conn.execute(['mv', tmpfile, destination], sudoable: true)
+              result = conn.execute(['mv', '-f', tmpfile, destination], sudoable: true)
               if result.exit_code != 0
                 message = "Could not move temporary file '#{tmpfile}' to #{destination}: #{result.stderr.string}"
                 raise Bolt::Node::FileError.new(message, 'MV_ERROR')

data/lib/bolt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.17.0
+  version: 1.18.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-19 00:00:00.000000000 Z
+date: 2019-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -381,6 +381,8 @@ files:
 - lib/bolt/pal/yaml_plan/evaluator.rb
 - lib/bolt/pal/yaml_plan/loader.rb
 - lib/bolt/plan_result.rb
+- lib/bolt/plugin.rb
+- lib/bolt/plugin/puppetdb.rb
 - lib/bolt/puppetdb.rb
 - lib/bolt/puppetdb/client.rb
 - lib/bolt/puppetdb/config.rb