bolt 1.34.0 → 1.35.0

data/lib/bolt/inventory/inventory2.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'bolt/inventory/group2'
+require 'bolt/inventory/target'
 
 module Bolt
   class Inventory
@@ -23,7 +24,7 @@ module Bolt
         @group_lookup = {}
         # The targets hash is the canonical source for all targets in inventory
         @targets = {}
-        @groups.resolve_aliases(@groups.target_aliases, @groups.target_names)
+        @groups.resolve_string_targets(@groups.target_aliases, @groups.all_targets)
         collect_groups
       end
 
@@ -49,34 +50,26 @@ module Bolt
       end
 
       def target_names
-        @groups.target_names
+        @groups.all_targets
       end
       # alias for analytics
       alias node_names target_names
 
       def get_targets(targets)
-        flat_target_list(targets).map { |t| update_target(t) }
+        target_array = expand_targets(targets)
+        if target_array.is_a? Array
+          target_array.flatten.uniq(&:name)
+        else
+          [target_array]
+        end
       end
 
       def get_target(target)
-        target_array = flat_target_list(target)
+        target_array = get_targets(target)
         if target_array.count > 1
           raise ValidationError.new("'#{target}' refers to #{target_array.count} targets", nil)
         end
-        get_targets(target_array.first).first
-      end
-
-      def add_to_group(targets, desired_group)
-        if group_names.include?(desired_group)
-          targets.each do |target|
-            if group_names.include?(target.name)
-              raise ValidationError.new("Group #{target.name} conflicts with target of the same name", target.name)
-            end
-            add_target(@groups, target, desired_group)
-          end
-        else
-          raise ValidationError.new("Group #{desired_group} does not exist in inventory", nil)
-        end
+        target_array.first
       end
 
       def data_hash
@@ -92,79 +85,9 @@ module Bolt
       end
 
       #### PRIVATE ####
-      #
-      # For debugging only now
-      def groups_in(target_name)
-        @groups.data_for(target_name)['groups'] || {}
-      end
-      private :groups_in
-
-      # Look for _plugins
-      def config_plugin(data)
-        Bolt::Util.walk_vals(data) do |val|
-          if val.is_a?(Concurrent::Delay)
-            # We should raise any error from the delay now
-            val.value!
-          else
-            val
-          end
-        end
-      end
-      private :config_plugin
-
-      # Pass a target to get_targets for a public version of this
-      def update_target(target)
-        # Ensure all targets in inventory are included in the all group.
-        unless @groups.target_names.include?(target.name)
-          add_to_group([target], 'all')
-        end
-
-        # Get merged data between targets and groups
-        data = @groups.data_for(target.name)
-        data ||= {}
-
-        unless data['config']
-          @logger.debug("Did not find config for #{target.name} in inventory")
-          data['config'] = {}
-        end
-
-        # Add defaults for special 'localhost' target (currently just config and features)
-        if target.name == 'localhost'
-          data = Bolt::Inventory.localhost_defaults(data)
-        end
-
-        # Data from inventory
-        data['config'] = config_plugin(data['config'])
-        # Data from set_config (make sure to resolve plugins)
-        resolved_target_config = config_plugin(@targets[target.name]['config'] || {})
-        data['config'] = Bolt::Util.deep_merge(data['config'], resolved_target_config)
-
-        # Use Config object to ensure config section is treated consistently with config file
-        conf = @config.deep_clone
-        conf.update_from_inventory(data['config'])
-        conf.validate
-
-        # Recompute the target cached state with the merged data
-        update_target_state(target, conf, data)
-
-        unless target.transport.nil? || Bolt::TRANSPORTS.include?(target.transport.to_sym)
-          raise Bolt::UnknownTransportError.new(target.transport, target.uri)
-        end
-
-        target
-      end
-      private :update_target
-
-      # This algorithm for getting a flat list of targets is used several times.
-      def flat_target_list(targets)
-        target_array = expand_targets(targets)
-        if target_array.is_a? Array
-          target_array.flatten.uniq(&:name)
-        else
-          [target_array]
-        end
+      def group_data_for(target_name)
+        @groups.group_collect(target_name)
       end
-      private :flat_target_list
 
       # If target is a group name, expand it to the members of that group.
       # Else match against targets in inventory by name or alias.
@@ -172,13 +95,13 @@ module Bolt
       # Else fall back to [target] if no matches are found.
       def resolve_name(target)
         if (group = @group_lookup[target])
-          group.target_names
+          group.all_targets
         else
           # Try to wildcard match targets in inventory
           # Ignore case because hostnames are generally case-insensitive
           regexp = Regexp.new("^#{Regexp.escape(target).gsub('\*', '.*?')}$", Regexp::IGNORECASE)
 
-          targets = @groups.target_names.select { |targ| targ =~ regexp }
+          targets = @groups.all_targets.select { |targ| targ =~ regexp }
           targets += @groups.target_aliases.select { |target_alias, _target| target_alias =~ regexp }.values
 
           if targets.empty?
@@ -201,8 +124,12 @@ module Bolt
           targets.split(/[[:space:],]+/).reject(&:empty?).map do |name|
             ts = resolve_name(name)
             ts.map do |t|
-              # If the target exists, return it, otherwise create one
-              @targets[t] ? @targets[t]['self'] : create_target(t)
+              # If the target doesn't exist, evaluate it from the inventory.
+              # Then return a Bolt::Target2.
+              unless @targets.key?(t)
+                @targets[t] = create_target_from_inventory(t)
+              end
+              Bolt::Target2.new(t, self)
             end
           end
         end
@@ -211,9 +138,9 @@ module Bolt
 
       def add_target(current_group, target, desired_group)
         if current_group.name == desired_group
-          current_group.add_target(target.target_data_hash)
+          current_group.add_target(target)
           @groups.validate
-          update_target(target)
+          target.invalidate_group_cache!
           return true
         end
         # Recurse on children Groups if not desired_group
@@ -223,170 +150,88 @@ module Bolt
       end
       private :add_target
 
-      # This is effectively the init method for Target2
-      def create_target(target_name, target_hash = nil)
-        # Prefer target hash, then data from inventoryfile, allow for uri only with empty hash
-        data = target_hash || @groups.target_collect(target_name) || {}
-        data = { 'uri' => target_name } if data['uri'].nil? && data['name'].nil?
-        data['uri_obj'] = Bolt::Inventory::Inventory2.parse_uri(data['uri'])
-
-        if data['uri'] && data['name'].nil?
-          data['name'] = data['uri']
-          data['safe_name'] = data['uri_obj'].omit(:password).to_str.sub(%r{^//}, '')
-        elsif data['name']
-          data['safe_name'] = data['name']
-        else
-          data['name'] = target_name
-          data['safe_name'] = if data['uri_obj']
-                                data['uri_obj'].omit(:password).to_str.sub(%r{^//}, '')
-                              else
-                                target_name
-                              end
-        end
-        unless data['name'].ascii_only?
-          raise ValidationError.new("Target name must be ASCII characters: #{data['name']}", nil)
-        end
-        # Data set on target itself (either in inventory, target.new or with set_config)
-        data['config'] ||= {}
-        data['vars'] ||= {}
-        data['facts'] ||= {}
-        data['features'] = data['features'] ? Set.new(data['features']) : Set.new
-        data['groups'] ||= []
-        data['options'] ||= {}
-        data['plugin_hooks'] ||= {}
-        data['target_alias'] ||= []
-
-        # Every call to update_target will rebuild this state based on merging together target, group, and config data
-        data['cached_state'] = {}
-
-        target = Target2.new(nil, data['name'])
-        target.inventory = self
-        data['self'] = target
-        @targets[data['name']] = data
+      # Pull in a target definition from the inventory file and evaluate any
+      # associated references. This is used when a target is resolved by
+      # get_targets.
+      def create_target_from_inventory(target_name)
+        target_data = @groups.target_collect(target_name) || { 'uri' => target_name }
+
+        target = Bolt::Inventory::Target.new(target_data, self)
+        @targets[target.name] = target
+
+        add_to_group([target], 'all')
+
         target
       end
-      private :create_target
 
+      # Add a brand new target, overriding any existing target with the same
+      # name. This method does not honor target config from the inventory. This
+      # is used when Target.new is called from a plan.
       def create_target_from_plan(data)
-        t_name = data['name'] || data['uri']
-
         # If target already exists, delete old and replace with new, otherwise add to new to all group
-        if @targets[t_name]
-          @targets.delete(t_name)
-          t = create_target(t_name, data)
-          update_target(t)
-        else
-          t = create_target(t_name, data)
-          update_target(t)
-          add_to_group([t], 'all')
+        new_target = Bolt::Inventory::Target.new(data, self)
+        existing_target = @targets.key?(new_target.name)
+        @targets[new_target.name] = new_target
+
+        unless existing_target
+          add_to_group([new_target], 'all')
         end
-        t
+
+        new_target
       end
 
-      def self.parse_uri(string)
-        require 'addressable/uri'
-        if string.nil?
-          nil
-        # Forbid empty uri
-        elsif string.empty?
-          raise Bolt::ParseError, "Could not parse target URI: URI is empty string"
-        elsif string =~ %r{^[^:]+://}
-          Addressable::URI.parse(string)
+      def add_to_group(targets, desired_group)
+        if group_names.include?(desired_group)
+          targets.each do |target|
+            if group_names.include?(target.name)
+              raise ValidationError.new("Group #{target.name} conflicts with target of the same name", target.name)
+            end
+            # Add the inventory copy of the target
+            add_target(@groups, @targets[target.name], desired_group)
+          end
         else
-          # Initialize with an empty scheme to ensure we parse the hostname correctly
-          Addressable::URI.parse("//#{string}")
+          raise ValidationError.new("Group #{desired_group} does not exist in inventory", nil)
         end
-      rescue Addressable::URI::InvalidURIError => e
-        raise Bolt::ParseError, "Could not parse target URI: #{e.message}"
       end
 
       def set_var(target, var_hash)
-        @targets[target.name]['vars'] = @targets[target.name]['vars'].merge(var_hash)
-        update_target(target)
+        @targets[target.name].set_var(var_hash)
       end
 
       def vars(target)
-        @targets[target.name]['cached_state']['vars'] || {}
+        @targets[target.name].vars
       end
 
       def add_facts(target, new_facts = {})
-        @targets[target.name]['facts'] = Bolt::Util.deep_merge(@targets[target.name]['facts'], new_facts)
-        update_target(target)
+        @targets[target.name].add_facts(new_facts)
         # rubocop:disable Style/GlobalVars
         $future ? target : facts(target)
         # rubocop:enable Style/GlobalVars
       end
 
       def facts(target)
-        @targets[target.name]['cached_state']['facts'] || {}
+        @targets[target.name].facts
       end
 
       def set_feature(target, feature, value = true)
-        if value
-          @targets[target.name]['features'] << feature
-        else
-          @targets[target.name]['features'].delete(feature)
-        end
-        update_target(target)
+        @targets[target.name].set_feature(feature, value)
       end
 
       def features(target)
-        if @targets[target.name]['cached_state']['features']
-          Set.new(@targets[target.name]['cached_state']['features'])
-        else
-          Set.new
-        end
+        @targets[target.name].features
       end
 
       def plugin_hooks(target)
-        @targets[target.name]['cached_state']['plugin_hooks'] || {}
+        @targets[target.name].plugin_hooks
       end
 
       def set_config(target, key_or_key_path, value)
-        config = key_or_key_path.empty? ? value : build_config_hash([key_or_key_path].flatten, value)
-        @targets[target.name]['config'] = @targets[target.name]['config'].merge(config)
-        update_target(target)
+        @targets[target.name].set_config(key_or_key_path, value)
       end
 
       def target_config(target)
-        @targets[target.name]['cached_state']['config'] || {}
-      end
-
-      def build_config_hash(key_or_key_path, value)
-        # https://stackoverflow.com/questions/5095077/ruby-convert-array-to-nested-hash
-        key_or_key_path.reverse.inject(value) { |acc, key| { key => acc } }
-      end
-      private :build_config_hash
-
-      def update_target_state(target, conf, merged_data)
-        @targets[target.name]['protocol'] = conf.transport_conf[:transport]
-        t_conf = conf.transport_conf[:transports][target.transport.to_sym] || {}
-        @targets[target.name]['user'] = t_conf['user']
-        @targets[target.name]['password'] = t_conf['password']
-        @targets[target.name]['port'] = t_conf['port']
-        @targets[target.name]['host'] = t_conf['host']
-        @targets[target.name]['options'] = t_conf
-
-        @targets[target.name]['cached_state'] = merged_data
-
-        target_facts = @targets[target.name]['facts'] || {}
-        new_facts = merged_data['facts'] || {}
-        @targets[target.name]['cached_state']['facts'] = Bolt::Util.deep_merge(new_facts, target_facts)
-
-        target_vars = @targets[target.name]['vars'] || {}
-        new_vars = merged_data['vars'] || {}
-        @targets[target.name]['cached_state']['vars'] = new_vars.merge(target_vars)
-
-        target_features = Set.new(@targets[target.name]['features'])
-        new_features = Set.new(merged_data['features'])
-        @targets[target.name]['cached_state']['features'] = new_features.merge(target_features)
-
-        target_plugin_hooks = @targets[target.name]['plugin_hooks'] || {}
-        new_plugin_hooks = merged_data['plugin_hooks'] || {}
-        plugin_hooks_from_inv = new_plugin_hooks.merge(target_plugin_hooks)
-        @targets[target.name]['cached_state']['plugin_hooks'] = conf.plugin_hooks.merge(plugin_hooks_from_inv)
+        @targets[target.name].config
       end
-      private :update_target_state
     end
   end
 end

data/lib/bolt/inventory/target.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Bolt
+  class Inventory
+    # This class represents the active state of a target within the inventory.
+    class Target
+      attr_reader :name, :uri, :safe_name
+
+      def initialize(target_data, inventory)
+        unless target_data['name'] || target_data['uri']
+          raise Bolt::Inventory::ValidationError.new("Target must have either a name or uri", nil)
+        end
+
+        @logger = Logging.logger[inventory]
+
+        # If the target isn't mentioned by any groups, it won't have a uri or
+        # name and we will use the target_name as both
+        @uri = target_data['uri']
+        @uri_obj = self.class.parse_uri(@uri)
+
+        # If the target has a name, use that as the safe name. Otherwise, turn
+        # the uri into a safe name by omitting the password.
+        if target_data['name']
+          @name = target_data['name']
+          @safe_name = target_data['name']
+        else
+          @name = @uri
+          @safe_name = @uri_obj.omit(:password).to_str.sub(%r{^//}, '')
+        end
+
+        @config = target_data['config'] || {}
+        @vars = target_data['vars'] || {}
+        @facts = target_data['facts'] || {}
+        @features = target_data['features'] || Set.new
+        @options = target_data['options'] || {}
+        @plugin_hooks = target_data['plugin_hooks'] || {}
+        @target_alias = target_data['target_alias'] || []
+
+        @inventory = inventory
+
+        validate
+      end
+
+      def vars
+        # XXX Return vars from the cache
+        group_cache['vars'].merge(@vars)
+      end
+
+      # This method isn't actually an accessor and we want the name to
+      # correspond to the Puppet function
+      # rubocop:disable Naming/AccessorMethodName
+      def set_var(var_hash)
+        @vars.merge!(var_hash)
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      def facts
+        # XXX Return facts from the cache
+        Bolt::Util.deep_merge(group_cache['facts'], @facts)
+      end
+
+      def add_facts(new_facts = {})
+        @facts = Bolt::Util.deep_merge(@facts, new_facts)
+      end
+
+      def features
+        group_cache['features'] + @features
+      end
+
+      def set_feature(feature, value = true)
+        if value
+          @features << feature
+        else
+          @features.delete(feature)
+        end
+      end
+
+      def plugin_hooks
+        # Merge plugin_hooks from the config file with any defined by the group
+        # or assigned dynamically to the target
+        @inventory.config.plugin_hooks.merge(group_cache['plugin_hooks']).merge(@plugin_hooks)
+      end
+
+      def set_config(key_or_key_path, value)
+        if key_or_key_path.empty?
+          @config = value
+        else
+          *path, key = Array(key_or_key_path)
+          location = path.inject(@config) do |working_object, p|
+            working_object[p] ||= {}
+          end
+          location[key] = value
+        end
+        invalidate_config_cache!
+      end
+
+      def invalidate_group_cache!
+        @group_cache = nil
+        # The config cache depends on the group cache, so invalidate it as well
+        invalidate_config_cache!
+      end
+
+      def invalidate_config_cache!
+        @transport_config_cache = nil
+      end
+
+      # Computing the transport config is expensive as it requires cloning the
+      # base config, so we cache the effective config
+      def transport_config_cache
+        if @transport_config_cache.nil?
+          merged_config = Bolt::Util.deep_merge(group_cache['config'], @config)
+          # Use the base config to ensure we handle the config validation and
+          # munging correctly
+          config = @inventory.config.deep_clone
+          config.update_from_inventory(merged_config)
+          config.validate
+          @transport_config_cache = {
+            'transport' => config.transport_conf[:transport],
+            'transports' => config.transport_conf[:transports]
+          }
+        end
+
+        @transport_config_cache
+      end
+
+      # Validate the target. This implicitly also primes the group and config
+      # caches and resolves any config references in the target's groups.
+      def validate
+        unless name.ascii_only?
+          raise Bolt::Inventory::ValidationError.new("Target name must be ASCII characters: #{@name}", nil)
+        end
+
+        unless transport.nil? || Bolt::TRANSPORTS.include?(transport.to_sym)
+          raise Bolt::UnknownTransportError.new(transport, uri)
+        end
+      end
+
+      def host
+        @uri_obj.hostname || transport_config['host']
+      end
+
+      def port
+        @uri_obj.port || transport_config['port']
+      end
+
+      def protocol
+        transport
+      end
+
+      def transport
+        @uri_obj.scheme || transport_config_cache['transport']
+      end
+
+      def user
+        Addressable::URI.unencode_component(@uri_obj.user) || transport_config['user']
+      end
+
+      def password
+        Addressable::URI.unencode_component(@uri_obj.password) || transport_config['password']
+      end
+
+      def options
+        transport_config.dup
+      end
+
+      # We only want to look up transport config keys for the configured
+      # transport
+      def transport_config
+        transport_config_cache['transports'][transport.to_sym]
+      end
+
+      def config
+        Bolt::Util.deep_merge(group_cache['config'], @config)
+      end
+
+      def group_cache
+        if @group_cache.nil?
+          group_data = @inventory.group_data_for(@name)
+
+          unless group_data && group_data['config']
+            @logger.debug("Did not find config for #{self} in inventory")
+          end
+
+          group_data ||= {
+            'config' => {},
+            'vars' => {},
+            'facts' => {},
+            'features' => Set.new,
+            'options' => {},
+            'plugin_hooks' => {},
+            'target_alias' => []
+          }
+
+          # This should be handled by `get_targets`
+          if @name == 'localhost'
+            group_data = Bolt::Inventory.localhost_defaults(group_data)
+          end
+
+          @group_cache = group_data
+        end
+
+        @group_cache
+      end
+
+      def to_s
+        @safe_name
+      end
+
+      def self.parse_uri(string)
+        require 'addressable/uri'
+        if string.nil?
+          Addressable::URI.new
+        # Forbid empty uri
+        elsif string.empty?
+          raise Bolt::ParseError, "Could not parse target URI: URI is empty string"
+        elsif string =~ %r{^[^:]+://}
+          Addressable::URI.parse(string)
+        else
+          # Initialize with an empty scheme to ensure we parse the hostname correctly
+          Addressable::URI.parse("//#{string}")
+        end
+      rescue Addressable::URI::InvalidURIError => e
+        raise Bolt::ParseError, "Could not parse target URI: #{e.message}"
+      end
+    end
+  end
+end