bolt 1.36.0 → 1.37.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc29b4aca58aa7208e448120f59687cb5fbdd0cbab78af55861b629420a9fb9e
-  data.tar.gz: 46ec4cca8088b69d9196f3c251084bdeadaee9b676aa4c33617fd0e40a711d20
+  metadata.gz: 4e9167735253231222010ffb141c42048039e6b02c13061dbc6394db8876a6d7
+  data.tar.gz: b10298a67bb280b58c265ce2238f91ac611b672eb3c303e9f507e15db6e05e7e
 SHA512:
-  metadata.gz: 0a0fbaff3412cc6cc7b92922fae45daf150b950d9f60a2eed1d8a97d32ffd404d7c7577167efe90fecf9425444e4acca5794ad8a49ca6248f0a91b6cb6598dec
-  data.tar.gz: da32512009bcbe140b70374ea331a0edbe95696df347311b0b0de07f8740818088c9c2fbfc136572c20c9008c953f205c5e855e048141c9e0a933ce1c77f6d09
+  metadata.gz: 857e83019439072c518e50ad9c9d1c0dc93cc0e8b536f53348824091d6367fdc6df4b08c2d6c9dbf0cb45fb7fda29051c2743d470e4bba82ec7b708d7ed997cc
+  data.tar.gz: f91623e0811677b7c9c9f643f3a512120e7af52edbaff7d74381b0d7a40556d77dc0f7c98cf7117fdd69db504b310681157e3c44367a27fe57089e6a3dc3dc41

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bolt/error'
+
+# Evaulates all _plugin references in a hash and returns the resolved reference data.
+Puppet::Functions.create_function(:resolve_references) do
+  # Resolve references.
+  # @param references A hash of reference data to resolve.
+  # @return A hash of resolved reference data.
+  # @example Resolve a hash of reference data
+  #   $references = {
+  #     "targets" => [
+  #       "_plugin" => "terraform",
+  #       "dir" => "path/to/terraform/project",
+  #       "resource_type" => "aws_instance.web",
+  #       "uri" => "public_ip"
+  #     ]
+  #   }
+  #
+  #   resolve_references($references)
+  dispatch :resolve_references do
+    param 'Data', :references
+    return_type 'Data'
+  end
+
+  def resolve_references(references)
+    unless Puppet[:tasks]
+      raise Puppet::ParseErrorWithIssue
+        .from_issue_and_stack(
+          Bolt::PAL::Issues::PLAN_OPERATION_NOT_SUPPORTED_WHEN_COMPILING,
+          action: 'resolve_references'
+        )
+    end
+
+    plugins = Puppet.lookup(:bolt_inventory).plugins
+    plugins.resolve_references(references)
+  end
+end

data/lib/bolt/bolt_option_parser.rb

@@ -396,13 +396,13 @@ module Bolt
       end
       define('-p', '--password [PASSWORD]',
              'Password to authenticate with') do |password|
-        # TODO: Remove deprecation message
-        unless password
-          msg = "Optional parameter for --password is deprecated and no longer prompts for password. " \
-                "Use the prompt plugin instead to prompt for passwords."
-          raise Bolt::CLIError, msg
+        if password.nil?
+          STDOUT.print "Please enter your password: "
+          @options[:password] = STDIN.noecho(&:gets).chomp
+          STDOUT.puts
+        else
+          @options[:password] = password
         end
-        @options[:password] = password
       end
       define('--private-key KEY', 'Private ssh key to authenticate with') do |key|
         @options[:'private-key'] = key
@@ -423,13 +423,13 @@ module Bolt
       end
       define('--sudo-password [PASSWORD]',
              'Password for privilege escalation') do |password|
-        # TODO: Remove deprecation message
-        unless password
-          msg = "Optional parameter for --sudo-password is deprecated and no longer prompts for password. " \
-                "Use the prompt plugin instead to prompt for passwords."
-          raise Bolt::CLIError, msg
+        if password.nil?
+          STDOUT.print "Please enter your privilege escalation password: "
+          @options[:'sudo-password'] = STDIN.noecho(&:gets).chomp
+          STDOUT.puts
+        else
+          @options[:'sudo-password'] = password
         end
-        @options[:'sudo-password'] = password
       end
 
       separator "\nRun context:"

data/lib/bolt/inventory/group2.rb

@@ -21,11 +21,11 @@ module Bolt
         @logger = Logging.logger[self]
         @plugins = plugins
 
-        input = resolve_top_level_references(input) if reference?(input)
+        input = @plugins.resolve_top_level_references(input) if @plugins.reference?(input)
 
         raise ValidationError.new("Group does not have a name", nil) unless input.key?('name')
 
-        @name = resolve_references(input['name'])
+        @name = @plugins.resolve_references(input['name'])
 
         raise ValidationError.new("Group name must be a String, not #{@name.inspect}", nil) unless @name.is_a?(String)
         raise ValidationError.new("Invalid group name #{@name}", @name) unless @name =~ NAME_REGEX
@@ -36,7 +36,7 @@ module Bolt
 
         validate_data_keys(@input)
 
-        targets = resolve_top_level_references(input.fetch('targets', []))
+        targets = @plugins.resolve_top_level_references(input.fetch('targets', []))
 
         @unresolved_targets = {}
         @resolved_targets = {}
@@ -65,83 +65,11 @@ module Bolt
         # them until we have a value. We don't just use resolve_references
         # though, since that will resolve any nested references and we want to
         # leave it to the group to do that lazily.
-        groups = resolve_top_level_references(groups)
+        groups = @plugins.resolve_top_level_references(groups)
 
         @groups = Array(groups).map { |g| Group2.new(g, plugins) }
       end
 
-      # Evaluate all _plugin references in a data structure. Leaves are
-      # evaluated and then their parents are evaluated with references replaced
-      # by their values. If the result of a reference contains more references,
-      # they are resolved again before continuing to ascend the tree. The final
-      # result will not contain any references.
-      def resolve_references(data)
-        Bolt::Util.postwalk_vals(data) do |value|
-          reference?(value) ? resolve_references(resolve_single_reference(value)) : value
-        end
-      end
-      private :resolve_references
-
-      # Iteratively resolves "top-level" references until the result no longer
-      # has top-level references. A top-level reference is one which is not
-      # contained within another hash. It may be either the actual top-level
-      # result or arbitrarily nested within arrays. If parameters of the
-      # reference are themselves references, they will be looked. Any remaining
-      # references nested inside the result will *not* be evaluated once the
-      # top-level result is not a reference.  This is used to resolve the
-      # `targets` and `groups` keys which are allowed to be references or
-      # arrays of references, but which may return data with nested references
-      # that should be resolved lazily. The end result will either be a single
-      # hash or a flat array of hashes.
-      def resolve_top_level_references(data)
-        if data.is_a?(Array)
-          data.flat_map { |elem| resolve_top_level_references(elem) }
-        elsif reference?(data)
-          partially_resolved = data.map do |k, v|
-            [k, resolve_references(v)]
-          end.to_h
-          fully_resolved = resolve_single_reference(partially_resolved)
-          # The top-level reference may have returned more references, so repeat the process
-          resolve_top_level_references(fully_resolved)
-        else
-          data
-        end
-      end
-      private :resolve_top_level_references
-
-      # Evaluates a single reference. The value returned may be another
-      # reference.
-      def resolve_single_reference(reference)
-        plugin_name = reference['_plugin']
-        begin
-          hook = @plugins.get_hook(plugin_name, :resolve_reference)
-        rescue Bolt::Plugin::PluginError => e
-          raise ValidationError.new(e.message, @name)
-        end
-
-        begin
-          validate_proc = @plugins.get_hook(plugin_name, :validate_resolve_reference)
-        rescue Bolt::Plugin::PluginError
-          validate_proc = proc { |*args| }
-        end
-
-        validate_proc.call(reference)
-
-        begin
-          # Evaluate the plugin and then recursively evaluate any plugin returned by it.
-          hook.call(reference)
-        rescue StandardError => e
-          loc = "resolve_reference in #{@name}"
-          raise Bolt::Plugin::PluginError::ExecutionError.new(e.message, plugin_name, loc)
-        end
-      end
-      private :resolve_single_reference
-
-      # Checks whether a given value is a _plugin reference
-      def reference?(input)
-        input.is_a?(Hash) && input.key?('_plugin')
-      end
-
       def target_data(target_name)
         if @unresolved_targets.key?(target_name)
           target = @unresolved_targets.delete(target_name)
@@ -170,9 +98,9 @@ module Bolt
           raise ValidationError.new("Target entry must be a Hash, not #{target.class}", @name)
         end
 
-        target['name'] = resolve_references(target['name']) if target.key?('name')
-        target['uri'] = resolve_references(target['uri']) if target.key?('uri')
-        target['alias'] = resolve_references(target['alias']) if target.key?('alias')
+        target['name'] = @plugins.resolve_references(target['name']) if target.key?('name')
+        target['uri'] = @plugins.resolve_references(target['uri']) if target.key?('uri')
+        target['alias'] = @plugins.resolve_references(target['alias']) if target.key?('alias')
 
         t_name = target['name'] || target['uri']
 
@@ -303,7 +231,7 @@ module Bolt
         end
 
         Bolt::Util.walk_keys(input) do |key|
-          if reference?(key)
+          if @plugins.reference?(key)
             raise ValidationError.new("Group keys cannot be specified as _plugin references", @name)
           else
             key
@@ -366,11 +294,11 @@ module Bolt
 
       def resolve_data_keys(data, target = nil)
         result = {
-          'config' => resolve_references(data.fetch('config', {})),
-          'vars' => resolve_references(data.fetch('vars', {})),
-          'facts' => resolve_references(data.fetch('facts', {})),
-          'features' => resolve_references(data.fetch('features', [])),
-          'plugin_hooks' => resolve_references(data.fetch('plugin_hooks', {}))
+          'config' => @plugins.resolve_references(data.fetch('config', {})),
+          'vars' => @plugins.resolve_references(data.fetch('vars', {})),
+          'facts' => @plugins.resolve_references(data.fetch('facts', {})),
+          'features' => @plugins.resolve_references(data.fetch('features', [])),
+          'plugin_hooks' => @plugins.resolve_references(data.fetch('plugin_hooks', {}))
         }
         validate_data_keys(result, target)
         result['features'] = Set.new(result['features'].flatten)
@@ -385,13 +313,13 @@ module Bolt
           'features' => Array,
           'plugin_hooks' => Hash
         }.each do |key, expected_type|
-          next if !data.key?(key) || data[key].is_a?(expected_type) || reference?(data[key])
+          next if !data.key?(key) || data[key].is_a?(expected_type) || @plugins.reference?(data[key])
 
           msg = +"Expected #{key} to be of type #{expected_type}, not #{data[key].class}"
           msg << " for target #{target}" if target
           raise ValidationError.new(msg, @name)
         end
-        unless reference?(data['config'])
+        unless @plugins.reference?(data['config'])
           unexpected_keys = data.fetch('config', {}).keys - CONFIG_KEYS
           if unexpected_keys.any?
             msg = +"Found unexpected key(s) #{unexpected_keys.join(', ')} in config for"

data/lib/bolt/plugin.rb

@@ -208,6 +208,72 @@ module Bolt
         nil
       end
     end
+
+    # Evaluate all _plugin references in a data structure. Leaves are
+    # evaluated and then their parents are evaluated with references replaced
+    # by their values. If the result of a reference contains more references,
+    # they are resolved again before continuing to ascend the tree. The final
+    # result will not contain any references.
+    def resolve_references(data)
+      Bolt::Util.postwalk_vals(data) do |value|
+        reference?(value) ? resolve_references(resolve_single_reference(value)) : value
+      end
+    end
+
+    # Iteratively resolves "top-level" references until the result no longer
+    # has top-level references. A top-level reference is one which is not
+    # contained within another hash. It may be either the actual top-level
+    # result or arbitrarily nested within arrays. If parameters of the
+    # reference are themselves references, they will be looked. Any remaining
+    # references nested inside the result will *not* be evaluated once the
+    # top-level result is not a reference.  This is used to resolve the
+    # `targets` and `groups` keys which are allowed to be references or
+    # arrays of references, but which may return data with nested references
+    # that should be resolved lazily. The end result will either be a single
+    # hash or a flat array of hashes.
+    def resolve_top_level_references(data)
+      if data.is_a?(Array)
+        data.flat_map { |elem| resolve_top_level_references(elem) }
+      elsif reference?(data)
+        partially_resolved = data.map do |k, v|
+          [k, resolve_references(v)]
+        end.to_h
+        fully_resolved = resolve_single_reference(partially_resolved)
+        # The top-level reference may have returned more references, so repeat the process
+        resolve_top_level_references(fully_resolved)
+      else
+        data
+      end
+    end
+
+    # Evaluates a single reference. The value returned may be another
+    # reference.
+    def resolve_single_reference(reference)
+      plugin_name = reference['_plugin']
+      hook = get_hook(plugin_name, :resolve_reference)
+
+      begin
+        validate_proc = get_hook(plugin_name, :validate_resolve_reference)
+      rescue PluginError
+        validate_proc = proc { |*args| }
+      end
+
+      validate_proc.call(reference)
+
+      begin
+        # Evaluate the plugin and then recursively evaluate any plugin returned by it.
+        hook.call(reference)
+      rescue StandardError => e
+        loc = "resolve_reference in #{plugin_name}"
+        raise PluginError::ExecutionError.new(e.message, plugin_name, loc)
+      end
+    end
+    private :resolve_single_reference
+
+    # Checks whether a given value is a _plugin reference
+    def reference?(input)
+      input.is_a?(Hash) && input.key?('_plugin')
+    end
   end
 end
 

data/lib/bolt/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bolt
 version: !ruby/object:Gem::Version
-  version: 1.36.0
+  version: 1.37.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-07 00:00:00.000000000 Z
+date: 2019-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -335,6 +335,7 @@ files:
 - bolt-modules/boltlib/lib/puppet/functions/get_targets.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/resolve_references.rb
 - bolt-modules/boltlib/lib/puppet/functions/run_command.rb
 - bolt-modules/boltlib/lib/puppet/functions/run_plan.rb
 - bolt-modules/boltlib/lib/puppet/functions/run_script.rb