bolt 0.21.3 → 0.21.4

data/lib/bolt/inventory.rb

@@ -41,10 +41,10 @@ module Bolt
         begin
           data = YAML.safe_load(ENV[ENVIRONMENT_VAR])
         rescue Psych::Exception
-          raise Bolt::Error.new("Could not parse inventory from $#{ENVIRONMENT_VAR}", 'bolt/parse-error')
+          raise Bolt::ParseError, "Could not parse inventory from $#{ENVIRONMENT_VAR}"
         end
       else
-        data = Bolt::Util.read_config_file(config[:inventoryfile], [config.default_inventory], 'inventory')
+        data = Bolt::Util.read_config_file(config.inventoryfile, config.default_inventoryfile, 'inventory')
       end
 
       inventory = new(data, config)
@@ -56,7 +56,7 @@ module Bolt
     def initialize(data, config = nil)
       @logger = Logging.logger[self]
       # Config is saved to add config options to targets
-      @config = config || Bolt::Config.new
+      @config = config || Bolt::Config.default
       @data = data ||= {}
       @groups = Group.new(data.merge('name' => 'all'))
       @group_lookup = {}

data/lib/bolt/logger.rb

@@ -27,12 +27,12 @@ module Bolt
       )
     end
 
-    def self.configure(config)
+    def self.configure(destinations, color)
       root_logger = Logging.logger[:root]
 
       root_logger.add_appenders Logging.appenders.stderr(
         'console',
-        layout: console_layout(config[:color]),
+        layout: console_layout(color),
         level: default_level
       )
 
@@ -40,7 +40,7 @@ module Bolt
       # limit what's actually logged in every appender individually.
       root_logger.level = :all
 
-      config[:log].each_pair do |name, params|
+      destinations.each_pair do |name, params|
         appender = Logging.appenders[name]
         if appender.nil?
           unless name.start_with?('file:')

data/lib/bolt/outputter/human.rb

@@ -165,11 +165,21 @@ module Bolt
       def print_plan_result(plan_result)
         if plan_result.value.nil?
           @stream.puts("Plan completed successfully with no result")
+        elsif plan_result.value.is_a? Bolt::ApplyFailure
+          @stream.puts(colorize(:red, plan_result.value.message))
         else
           @stream.puts(::JSON.pretty_generate(plan_result, quirks_mode: true))
         end
       end
 
+      def print_puppetfile_result(success, puppetfile, moduledir)
+        if success
+          @stream.puts("Successfully synced modules from #{puppetfile} to #{moduledir}")
+        else
+          @stream.puts(colorize(:red, "Failed to sync modules from #{puppetfile} to #{moduledir}"))
+        end
+      end
+
       def fatal_error(err)
         @stream.puts(colorize(:red, err.message))
         if err.is_a? Bolt::RunFailure

data/lib/bolt/outputter/json.rb

@@ -57,6 +57,12 @@ module Bolt
         @stream.puts result.to_json
       end
 
+      def print_puppetfile_result(success, puppetfile, moduledir)
+        @stream.puts({ "success": success,
+                       "puppetfile": puppetfile,
+                       "moduledir": moduledir }.to_json)
+      end
+
       def fatal_error(err)
         @stream.puts "],\n" if @items_open
         @stream.puts '"_error": ' if @object_open

data/lib/bolt/pal.rb

@@ -36,7 +36,7 @@ module Bolt
       end
     end
 
-    def initialize(config)
+    def initialize(modulepath, hiera_config, max_compiles = Concurrent.processor_count)
       # Nothing works without initialized this global state. Reinitializing
       # is safe and in practice only happen in tests
       self.class.load_puppet
@@ -44,7 +44,9 @@ module Bolt
       # This makes sure we don't accidentally create puppet dirs
       with_puppet_settings { |_| nil }
 
-      @config = config
+      @modulepath = [BOLTLIB_PATH, *modulepath, MODULES_PATH]
+      @hiera_config = hiera_config
+      @max_compiles = max_compiles
     end
 
     # Puppet logging is global so this is class method to avoid confusion
@@ -86,15 +88,11 @@ module Bolt
       compiler.evaluate_string('type PlanResult = Boltlib::PlanResult')
     end
 
-    def full_modulepath(modulepath)
-      [BOLTLIB_PATH, *modulepath, MODULES_PATH]
-    end
-
     # Runs a block in a PAL script compiler configured for Bolt.  Catches
     # exceptions thrown by the block and re-raises them ensuring they are
     # Bolt::Errors since the script compiler block will squash all exceptions.
     def in_bolt_compiler
-      r = Puppet::Pal.in_tmp_environment('bolt', modulepath: full_modulepath(@config[:modulepath]), facts: {}) do |pal|
+      r = Puppet::Pal.in_tmp_environment('bolt', modulepath: @modulepath, facts: {}) do |pal|
         pal.with_script_compiler do |compiler|
           alias_types(compiler)
           begin
@@ -122,10 +120,10 @@ module Bolt
         apply_executor: Applicator.new(
           inventory,
           executor,
-          full_modulepath(@config[:modulepath]),
-          @config.puppetdb,
-          @config[:'hiera-config'],
-          @config[:'compile-concurrency']
+          @modulepath,
+          pdb_client,
+          @hiera_config,
+          @max_compiles
         )
       }
       Puppet.override(opts, &block)
@@ -161,6 +159,7 @@ module Bolt
         end
         Puppet.settings.send(:clear_everything_for_tests)
         Puppet.initialize_settings(cli)
+        Puppet::GettextConfig.create_default_text_domain
         self.class.configure_logging
         yield
       end

data/lib/bolt/pal/logging.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'bolt/util/puppet_log_level'
+
 Puppet::Util::Log.newdesttype :logging do
   match "Logging::Logger"
 
@@ -7,22 +9,9 @@ Puppet::Util::Log.newdesttype :logging do
   # an explicit mapping.
   def initialize(logger)
     @external_logger = logger
-
-    @log_level_map = {
-      debug: :debug,
-      info: :info,
-      notice: :notice,
-      warning: :warn,
-      err: :error,
-      # Nothing in Puppet actually uses alert, emerg or crit, so it's hard to say
-      # what they indicate, but they sound pretty bad.
-      alert: :error,
-      emerg: :fatal,
-      crit: :fatal
-    }
   end
 
   def handle(log)
-    @external_logger.send(@log_level_map[log.level], log.to_s)
+    @external_logger.send(Bolt::Util::PuppetLogLevel::MAPPING[log.level], log.to_s)
   end
 end

data/lib/bolt/puppetdb/client.rb

@@ -7,30 +7,10 @@ require 'httpclient'
 module Bolt
   module PuppetDB
     class Client
-      def self.from_config(config)
-        uri = if config['server_urls'].is_a? String
-                config['server_urls']
-              else
-                config['server_urls'].first
-              end
-        uri = URI.parse(uri)
-        uri.port ||= 8081
+      attr_reader :config
 
-        cacert = File.expand_path(config['cacert'])
-        token = config.token
-
-        cert = config['cert']
-        key = config['key']
-
-        new(uri, cacert, token: token, cert: cert, key: key)
-      end
-
-      def initialize(uri, cacert, token: nil, cert: nil, key: nil)
-        @uri = uri
-        @cacert = cacert
-        @token = token
-        @cert = cert
-        @key = key
+      def initialize(config)
+        @config = config
       end
 
       def query_certnames(query)
@@ -61,7 +41,7 @@ module Bolt
 
       def make_query(query, path = nil)
         body = JSON.generate(query: query)
-        url = "#{@uri}/pdb/query/v4"
+        url = "#{@config.uri}/pdb/query/v4"
         url += "/#{path}" if path
 
         begin
@@ -82,15 +62,15 @@ module Bolt
       def http_client
         return @http if @http
         @http = HTTPClient.new
-        @http.ssl_config.set_client_cert_file(@cert, @key) if @cert
-        @http.ssl_config.add_trust_ca(@cacert)
+        @http.ssl_config.set_client_cert_file(@config.cert, @config.key) if @config.cert
+        @http.ssl_config.add_trust_ca(@config.cacert)
 
         @http
       end
 
       def headers
         headers = { 'Content-Type' => 'application/json' }
-        headers['X-Authentication'] = @token if @token
+        headers['X-Authentication'] = @config.token if @config.token
         headers
       end
     end

data/lib/bolt/puppetdb/config.rb

@@ -11,14 +11,7 @@ module Bolt
                          global: '/etc/puppetlabs/client-tools/puppetdb.conf',
                          win_global: 'C:/ProgramData/PuppetLabs/client-tools/puppetdb.conf' }.freeze
 
-      def initialize(config_file, options)
-        @settings = load_config(config_file)
-        @settings.merge!(options)
-        expand_paths
-        validate
-      end
-
-      def load_config(filename)
+      def self.load_config(filename, options)
         global_path = Bolt::Util.windows? ? DEFAULT_CONFIG[:win_global] : DEFAULT_CONFIG[:global]
         if filename
           if File.exist?(filename)
@@ -33,22 +26,24 @@ module Bolt
         else
           config = {}
         end
-        config.fetch('puppetdb', {})
+        config = config.fetch('puppetdb', {})
+        new(config.merge(options))
+      end
+
+      def initialize(settings)
+        @settings = settings
+        expand_paths
       end
 
       def token
         return @token if @token
         if @settings['token']
-          File.read(@settings['token'])
+          @token = File.read(@settings['token'])
         elsif File.exist?(DEFAULT_TOKEN)
-          File.read(DEFAULT_TOKEN)
+          @token = File.read(DEFAULT_TOKEN)
         end
       end
 
-      def [](key)
-        @settings[key]
-      end
-
       def expand_paths
         %w[cacert cert key token].each do |file|
           @settings[file] = File.expand_path(@settings[file]) if @settings[file]
@@ -59,24 +54,56 @@ module Bolt
         if @settings[file] && !File.exist?(@settings[file])
           raise Bolt::PuppetDBError, "#{file} file #{@settings[file]} does not exist"
         end
+        true
       end
 
-      def validate
-        unless @settings['server_urls']
-          raise Bolt::PuppetDBError, "server_urls must be specified"
-        end
-        unless @settings['cacert']
+      def uri
+        return @uri if @uri
+        uri = case @settings['server_urls']
+              when String
+                @settings['server_urls']
+              when Array
+                @settings['server_urls'].first
+              when nil
+                raise Bolt::PuppetDBError, "server_urls must be specified"
+              else
+                raise Bolt::PuppetDBError, "server_urls must be a string or array"
+              end
+
+        @uri = URI.parse(uri)
+        @uri.port ||= 8081
+        @uri
+      end
+
+      def cacert
+        if @settings['cacert'] && validate_file_exists('cacert')
+          @settings['cacert']
+        else
           raise Bolt::PuppetDBError, "cacert must be specified"
         end
+      end
+
+      def cert
+        validate_cert_and_key
+        validate_file_exists('cert')
+        @settings['cert']
+      end
 
+      def key
+        validate_cert_and_key
+        validate_file_exists('key')
+        @settings['key']
+      end
+
+      def validate_cert_and_key
         if (@settings['cert'] && !@settings['key']) ||
            (!@settings['cert'] && @settings['key'])
           raise Bolt::PuppetDBError, "cert and key must be specified together"
         end
+      end
 
-        validate_file_exists('cacert')
-        validate_file_exists('cert')
-        validate_file_exists('key')
+      def to_hash
+        @settings.dup
       end
     end
   end

data/lib/bolt/r10k_log_proxy.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'log4r/outputter/outputter'
+
+module Bolt
+  class R10KLogProxy < Log4r::Outputter
+    def initialize
+      super('bolt')
+
+      @logger = Logging.logger[self]
+    end
+
+    def canonical_log(event)
+      level = to_bolt_level(event.level)
+      @logger.send(level, event.data)
+    end
+
+    # Convert an r10k log level to a bolt log level. These correspond 1-to-1
+    # except that r10k has debug, debug1, and debug2. The log event has the log
+    # level as an integer that we need to look up.
+    def to_bolt_level(level_num)
+      level_str = Log4r::LNAMES[level_num]&.downcase || 'debug'
+      if level_str =~ /debug/
+        :debug
+      else
+        level_str.to_sym
+      end
+    end
+  end
+end

data/lib/bolt/util.rb

@@ -104,9 +104,9 @@ module Bolt
           end
 
           cl.instance_variables.each do |var|
-            v = cl.instance_eval { var }
+            v = cl.instance_variable_get(var)
             v_cl = deep_clone(v, cloned)
-            cl.instance_eval { @var = v_cl }
+            cl.instance_variable_set(var, v_cl)
           end
 
           return cl

data/lib/bolt/util/puppet_log_level.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Util
+    module PuppetLogLevel
+      MAPPING = {
+        debug: :debug,
+        info: :info,
+        notice: :notice,
+        warning: :warn,
+        err: :error,
+        # The following are used by Puppet functions of the same name, and are all treated as
+        # error types in the Windows EventLog and log colors.
+        alert: :error,
+        emerg: :fatal,
+        crit: :fatal
+      }.freeze
+    end
+  end
+end

data/lib/bolt/version.rb

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

data/lib/bolt_ext/puppetdb_inventory.rb

@@ -71,7 +71,7 @@ query results.
 
         if @show_help
           puts @parser.help
-          return 0
+          return
         end
 
         inventory_file = positional_args.shift
@@ -83,8 +83,8 @@ query results.
           raise "Unknown argument(s) #{positional_args.join(', ')}"
         end
 
-        config = Bolt::PuppetDB::Config.new(@config_file, @cli_opts)
-        @puppetdb_client = Bolt::PuppetDB::Client.from_config(config)
+        config = Bolt::PuppetDB::Config.load_config(@config_file, @cli_opts)
+        @puppetdb_client = Bolt::PuppetDB::Client.new(config)
 
         unless File.readable?(inventory_file)
           raise "Can't read the inventory file #{inventory_file}"
@@ -100,12 +100,6 @@ query results.
         else
           puts result
         end
-
-        0
-      rescue StandardError => e
-        puts "Error: #{e}"
-        puts e.backtrace if @trace
-        1
       end
 
       def resolve_group(group)