openbolt 5.0.0.rc1

data/lib/bolt/inventory/target.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require_relative '../../bolt/resource_instance'
+
+module Bolt
+  class Inventory
+    # This class represents the active state of a target within the inventory.
+    class Target
+      attr_reader :name, :uri, :safe_name, :target_alias, :resources
+
+      # Illegal characters that are not permitted in target names.
+      # These characters are delimiters for target and group names and allowing
+      # them would cause unexpected behavior.
+      ILLEGAL_CHARS = /[\s,]/.freeze
+
+      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 = Bolt::Logger.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
+        # handle special localhost target
+        if @name == 'localhost'
+          default = { 'config' => { 'transport' => 'local' } }
+          target_data = Bolt::Util.deep_merge(default, target_data)
+        end
+
+        @config = target_data['config'] || {}
+        @vars = target_data['vars'] || {}
+        @facts = target_data['facts'] || {}
+        @features = target_data['features'] || Set.new
+        @plugin_hooks = target_data['plugin_hooks'] || {}
+        # When alias is specified in a plan, the key will be `target_alias`, when
+        # alias is specified in inventory the key will be `alias`.
+        @target_alias = target_data['target_alias'] || target_data['alias'] || []
+        @resources = {}
+
+        @inventory = inventory
+
+        validate
+        # after setting config, apply local defaults when using bundled ruby
+        set_local_defaults if transport_config['bundled-ruby']
+      end
+
+      def set_local_defaults
+        return if @set_local_default
+        defaults = {
+          'local' => { 'interpreters' => { '.rb' => RbConfig.ruby } }
+        }
+        old_config = @config
+        @config = Bolt::Util.deep_merge(defaults, @config)
+        invalidate_config_cache! if old_config != @config
+        set_feature('puppet-agent')
+        @set_local_default = true
+      end
+
+      # rubocop:disable Naming/AccessorMethodName
+      def set_resource(resource)
+        if (existing_resource = resources[resource.reference])
+          existing_resource.overwrite_state(resource.state)
+          existing_resource.overwrite_desired_state(resource.desired_state)
+          existing_resource.events = existing_resource.events + resource.events
+          existing_resource
+        else
+          @resources[resource.reference] = resource
+        end
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      def vars
+        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
+        Bolt::Util.deep_merge(group_cache['facts'], @facts)
+      end
+
+      def add_facts(new_facts = {})
+        validate_fact_names(new_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 resource(type, title)
+        resources[Bolt::ResourceInstance.format_reference(type, title)]
+      end
+
+      def plugin_hooks
+        # Merge plugin_hooks from the config file with any defined by the group
+        # or assigned dynamically to the target
+        @inventory.plugins.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 = nil
+        @transport_config = nil
+      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
+
+        if (illegal_char = @name.match(ILLEGAL_CHARS))
+          raise ValidationError.new("Illegal character '#{illegal_char}' in target name '#{@name}'", nil)
+        end
+
+        unless transport.nil? || Bolt::TRANSPORTS.include?(transport.to_sym)
+          raise Bolt::UnknownTransportError.new(transport, uri)
+        end
+
+        validate_fact_names(facts)
+
+        transport_config
+      end
+
+      # Validate fact names and issue a deprecation warning if any fact names have a dot.
+      #
+      private def validate_fact_names(facts)
+        if (dotted = facts.keys.select { |name| name.include?('.') }).any?
+          Bolt::Logger.deprecate(
+            'dotted_fact_name',
+            "Target '#{safe_name}' includes dotted fact names: '#{dotted.join("', '")}'. Dotted fact "\
+            "names are deprecated and Bolt does not automatically convert facts with dotted names to "\
+            "structured facts. For more information, see https://pup.pt/bolt-dotted-facts"
+          )
+        end
+      end
+
+      def host
+        @uri_obj.hostname || transport_config['host']
+      end
+
+      def port
+        @uri_obj.port || transport_config['port']
+      end
+
+      # For remote targets, protocol is the value of the URI scheme. For
+      # non-remote targets, there is no protocol.
+      def protocol
+        if remote?
+          @uri_obj.scheme
+        end
+      end
+
+      # For remote targets, the transport is always 'remote'. Otherwise, it
+      # will be either the URI scheme or set explicitly.
+      def transport
+        if @transport.nil?
+          config_transport = @config['transport'] ||
+                             group_cache.dig('config', 'transport') ||
+                             @inventory.transport
+
+          @transport = if @uri_obj.scheme == 'remote' || config_transport == 'remote'
+                         'remote'
+                       else
+                         @uri_obj.scheme || config_transport
+                       end
+        end
+
+        @transport
+      end
+
+      def remote?
+        transport == 'remote'
+      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
+
+      # We only want to look up transport config keys for the configured
+      # transport
+      def transport_config
+        if @transport_config.nil?
+          config = @inventory.config[transport]
+                             .merge(group_cache.dig('config', transport), @config[transport])
+          @transport_config = config
+        end
+
+        @transport_config
+      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,
+            'plugin_hooks' => {},
+            'target_alias' => []
+          }
+
+          @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

data/lib/bolt/inventory.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative '../bolt/config'
+require_relative 'inventory/group'
+require_relative 'inventory/inventory'
+require_relative 'inventory/options'
+require_relative '../bolt/target'
+require_relative '../bolt/util'
+require_relative '../bolt/plugin'
+require_relative '../bolt/validator'
+require 'yaml'
+
+module Bolt
+  class Inventory
+    include Bolt::Inventory::Options
+
+    ENVIRONMENT_VAR = 'BOLT_INVENTORY'
+
+    class ValidationError < Bolt::Error
+      attr_accessor :path
+
+      def initialize(message, offending_group)
+        super(message, 'bolt.inventory/validation-error')
+        @_message = message
+        @path = [offending_group].compact
+      end
+
+      def details
+        { 'path' => path }
+      end
+
+      def add_parent(parent_group)
+        @path << parent_group
+      end
+
+      def message
+        if path.empty?
+          @_message
+        else
+          "#{@_message} for group at #{path}"
+        end
+      end
+    end
+
+    class WildcardError < Bolt::Error
+      def initialize(target)
+        super("Found 0 nodes matching wildcard pattern #{target}", 'bolt.inventory/wildcard-error')
+      end
+    end
+
+    # Builds the schema used by the validator.
+    #
+    def self.schema
+      schema = {
+        type:        Hash,
+        properties:  OPTIONS.map { |opt| [opt, _ref: opt] }.to_h,
+        definitions: DEFINITIONS,
+        _plugin:     true
+      }
+
+      schema[:definitions]['config'][:properties] = Bolt::Config.transport_definitions
+      schema
+    end
+
+    def self.from_config(config, plugins)
+      logger = Bolt::Logger.logger(self)
+
+      if ENV.include?(ENVIRONMENT_VAR)
+        begin
+          source = ENVIRONMENT_VAR
+          data = YAML.safe_load(ENV[ENVIRONMENT_VAR])
+          raise Bolt::ParseError, "Could not parse inventory from $#{ENVIRONMENT_VAR}" unless data.is_a?(Hash)
+          logger.debug("Loaded inventory from environment variable #{ENVIRONMENT_VAR}")
+        rescue Psych::Exception
+          raise Bolt::ParseError, "Could not parse inventory from $#{ENVIRONMENT_VAR}"
+        end
+      elsif config.inventoryfile
+        source = config.inventoryfile
+        data = Bolt::Util.read_yaml_hash(config.inventoryfile, 'inventory')
+        logger.debug("Loaded inventory from #{config.inventoryfile}")
+      else
+        source = config.default_inventoryfile
+        data = Bolt::Util.read_optional_yaml_hash(config.default_inventoryfile, 'inventory')
+
+        if config.default_inventoryfile.exist?
+          logger.debug("Loaded inventory from #{config.default_inventoryfile}")
+        else
+          source = nil
+          logger.debug("Tried to load inventory from #{config.default_inventoryfile}, but the file does not exist")
+        end
+      end
+
+      Bolt::Validator.new.tap do |validator|
+        validator.validate(data, schema, source)
+        validator.warnings.each { |warning| Bolt::Logger.warn(warning[:id], warning[:msg]) }
+      end
+
+      create_version(data, config.transport, config.transports, plugins, source)
+    end
+
+    def self.create_version(data, transport, transports, plugins, source = nil)
+      version = (data || {}).delete('version') { 2 }
+
+      case version
+      when 2
+        Bolt::Inventory::Inventory.new(data, transport, transports, plugins, source)
+      else
+        raise ValidationError.new("Unsupported version #{version} specified in inventory", nil)
+      end
+    end
+
+    def self.empty
+      config  = Bolt::Config.default
+      plugins = Bolt::Plugin.new(config, nil)
+
+      create_version({}, config.transport, config.transports, plugins, nil)
+    end
+  end
+end

data/lib/bolt/logger.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require 'logging'
+
+module Bolt
+  module Logger
+    LEVELS = %w[trace debug info warn error fatal].freeze
+
+    # This module is treated as a global singleton so that multiple classes
+    # in Bolt can log warnings with IDs. Access to the following variables
+    # are controlled by a mutex.
+    @mutex            = Mutex.new
+    @warnings         = Set.new
+    @disable_warnings = Set.new
+    @message_queue    = []
+
+    # This method provides a single point-of-entry to setup logging for both
+    # the CLI and for tests. This is necessary because we define custom log
+    # levels which create corresponding methods on the logger instances;
+    # without first initializing the Logging system, calls to those methods
+    # will fail.
+    def self.initialize_logging
+      # Initialization isn't idempotent and will result in warnings about const
+      # redefs, so skip it if the log levels we expect are present. If it's
+      # already been initialized with an insufficient set of levels, go ahead
+      # and call init anyway or we'll have failures when calling log methods
+      # for missing levels.
+      unless levels & LEVELS == LEVELS
+        Logging.init(*LEVELS)
+      end
+
+      # As above, only create the color scheme if we haven't already created it.
+      unless Logging.color_scheme('bolt')
+        Logging.color_scheme(
+          'bolt',
+          lines: {
+            warn: :yellow,
+            error: :red,
+            fatal: %i[white on_red]
+          }
+        )
+      end
+    end
+
+    def self.configure(destinations, color, disable_warnings = nil)
+      root_logger = Bolt::Logger.logger(:root)
+
+      root_logger.add_appenders Logging.appenders.stderr(
+        'console',
+        layout: console_layout(color),
+        level: default_console_level
+      )
+
+      # We set the root logger's level so that it logs everything but we do
+      # limit what's actually logged in every appender individually.
+      root_logger.level = :all
+
+      destinations.each_pair do |name, params|
+        appender = Logging.appenders[name]
+        if appender.nil?
+          unless name.start_with?('file:')
+            raise Bolt::Error.new("Unexpected log: #{name}", 'bolt/internal-error')
+          end
+
+          begin
+            appender = Logging.appenders.file(
+              name,
+              filename: name[5..-1], # strip the "file:" prefix
+              truncate: (params[:append] == false),
+              layout: default_layout,
+              level: default_file_level
+            )
+          rescue ArgumentError => e
+            raise Bolt::Error.new("Failed to open log #{name}: #{e.message}", 'bolt/log-error')
+          end
+
+          root_logger.add_appenders appender
+        end
+
+        appender.level = params[:level] if params[:level]
+      end
+
+      # Set the list of disabled warnings and mark the logger as configured.
+      # Log all messages in the message queue and flush the queue.
+      if disable_warnings
+        @mutex.synchronize { @disable_warnings = disable_warnings }
+      end
+    end
+
+    def self.configured?
+      Logging.logger[:root].appenders.any?
+    end
+
+    def self.stream
+      @stream
+    end
+
+    def self.stream=(stream)
+      @stream = stream
+    end
+
+    # A helper to ensure the Logging library is always initialized with our
+    # custom log levels before retrieving a Logger instance.
+    def self.logger(name)
+      initialize_logging
+      Logging.logger[name]
+    end
+
+    def self.analytics=(analytics)
+      @analytics = analytics
+    end
+
+    def self.console_layout(color)
+      color_scheme = :bolt if color
+      Logging.layouts.pattern(
+        pattern: '%m\e[0m\n',
+        color_scheme: color_scheme
+      )
+    end
+
+    def self.default_layout
+      Logging.layouts.pattern(
+        pattern: '%d %-6l [%T] [%c] %m\n',
+        date_pattern: '%Y-%m-%dT%H:%M:%S.%6N'
+      )
+    end
+
+    def self.default_console_level
+      :warn
+    end
+
+    def self.default_file_level
+      :warn
+    end
+
+    # Explicitly check the log level names instead of the log level number, as levels
+    # that are stringified integers (e.g. "level" => "42") will return a truthy value
+    def self.valid_level?(level)
+      Logging::LEVELS.include?(Logging.levelify(level))
+    end
+
+    def self.levels
+      Logging::LNAMES.map(&:downcase)
+    end
+
+    def self.reset_logging
+      Logging.reset
+    end
+
+    # The following methods are used in place of the Logging.logger
+    # methods of the same name when logging warning messages or logging
+    # any messages prior to the logger being configured. If the logger
+    # is not configured when any of these methods are called, the message
+    # will be added to a queue, otherwise they are logged immediately.
+    # The message queue is flushed by calling #flush_queue, which is
+    # called from Bolt::CLI after configuring the logger.
+    #
+    def self.warn(id, msg)
+      log(type: :warn, msg: "#{msg} [ID: #{id}]", id: id)
+    end
+
+    def self.warn_once(id, msg)
+      log(type: :warn_once, msg: "#{msg} [ID: #{id}]", id: id)
+    end
+
+    def self.deprecate(id, msg)
+      log(type: :deprecate, msg: "#{msg} [ID: #{id}]", id: id)
+    end
+
+    def self.deprecate_once(id, msg)
+      log(type: :deprecate_once, msg: "#{msg} [ID: #{id}]", id: id)
+    end
+
+    def self.debug(msg)
+      log(type: :debug, msg: msg)
+    end
+
+    def self.info(msg)
+      log(type: :info, msg: msg)
+    end
+
+    # Logs a message. If the logger has not been configured, this will queue
+    # the message to be logged later. Once the logger is configured, the
+    # queue will be flushed of all messages and new messages will be logged
+    # immediately.
+    #
+    # Logging with this method is controlled by a mutex, as the Bolt::Logger
+    # module is treated as a global singleton to allow multiple classes
+    # access to its methods.
+    #
+    private_class_method def self.log(type:, msg:, id: nil)
+      @mutex.synchronize do
+        if configured?
+          log_message(type: type, msg: msg, id: id)
+        else
+          @message_queue << { type: type, msg: msg, id: id }
+        end
+      end
+    end
+
+    # Logs all messages in the message queue and then flushes the queue.
+    #
+    def self.flush_queue
+      @mutex.synchronize do
+        @message_queue.each do |message|
+          log_message(**message)
+        end
+
+        @message_queue.clear
+      end
+    end
+
+    # Handles the actual logging of a message.
+    #
+    private_class_method def self.log_message(type:, msg:, id: nil)
+      case type
+      when :warn
+        do_warn(msg, id)
+      when :warn_once
+        do_warn_once(msg, id)
+      when :deprecate
+        do_deprecate(msg, id)
+      when :deprecate_once
+        do_deprecate_once(msg, id)
+      else
+        logger(self).send(type, msg)
+      end
+    end
+
+    # The following methods do the actual warning.
+    #
+    private_class_method def self.do_warn(msg, id)
+      return if @disable_warnings.include?(id)
+      logger(self).warn(msg)
+    end
+
+    private_class_method def self.do_warn_once(msg, id)
+      return unless @warnings.add?(id)
+      do_warn(msg, id)
+    end
+
+    private_class_method def self.do_deprecate(msg, id)
+      @analytics&.event('Warn', 'deprecation', label: id)
+      do_warn(msg, id)
+    end
+
+    private_class_method def self.do_deprecate_once(msg, id)
+      @analytics&.event('Warn', 'deprecation', label: id)
+      do_warn_once(msg, id)
+    end
+  end
+end