bolt 0.18.1 → 0.18.2

data/lib/bolt/config.rb

@@ -16,11 +16,17 @@ module Bolt
     local: Bolt::Transport::Local
   }.freeze
 
+  class UnknownTransportError < Bolt::Error
+    def initialize(transport, uri = nil)
+      msg = uri.nil? ? "Unknown transport #{transport}" : "Unknown transport #{transport} found for #{uri}"
+      super(msg, 'bolt/unknown-transport')
+    end
+  end
+
   Config = Struct.new(
     :concurrency,
     :format,
     :inventoryfile,
-    :log_level,
     :log,
     :modulepath,
     :puppetdb,
@@ -204,6 +210,10 @@ module Bolt
         raise Bolt::CLIError, "Unsupported format: '#{self[:format]}'"
       end
 
+      unless self[:transport].nil? || Bolt::TRANSPORTS.include?(self[:transport].to_sym)
+        raise UnknownTransportError, self[:transport]
+      end
+
       TRANSPORTS.each do |transport, impl|
         impl.validate(self[:transports][transport])
       end

data/lib/bolt/executor.rb

@@ -19,16 +19,12 @@ module Bolt
     def initialize(config = Bolt::Config.new, noop = nil, plan_logging = false)
       @config = config
       @logger = Logging.logger[self]
+      @plan_logging = plan_logging
 
       @transports = Bolt::TRANSPORTS.each_with_object({}) do |(key, val), coll|
         coll[key.to_s] = Concurrent::Delay.new { val.new }
       end
 
-      # If a specific elevated log level has been requested, honor that.
-      # Otherwise, escalate the log level to "info" if running in plan mode, so
-      # that certain progress messages will be visible.
-      default_log_level = plan_logging ? :info : :notice
-      @logger.level = @config[:log_level] || default_log_level
       @noop = noop
       @run_as = nil
       @pool = Concurrent::CachedThreadPool.new(max_threads: @config[:concurrency])
@@ -43,11 +39,11 @@ module Bolt
       impl.value
     end
 
-    def summary(action, object, result)
+    def summary(description, result)
       fc = result.error_set.length
       npl = result.length == 1 ? '' : 's'
       fpl = fc == 1 ? '' : 's'
-      "Ran #{action} '#{object}' on #{result.length} node#{npl} with #{fc} failure#{fpl}"
+      "Finished: #{description} on #{result.length} node#{npl} with #{fc} failure#{fpl}"
     end
     private :summary
 
@@ -97,75 +93,88 @@ module Bolt
       ResultSet.new(promises.map(&:value))
     end
 
+    # When running a plan, info messages like starting a task are promoted to notice.
+    def log_action(msg)
+      @plan_logging ? @logger.notice(msg) : @logger.info(msg)
+    end
+    private :log_action
+
+    def with_node_logging(description, batch)
+      @logger.info("#{description} on #{batch.map(&:uri)}")
+      result = yield
+      @logger.info(result.to_json)
+      result
+    end
+    private :with_node_logging
+
     def run_command(targets, command, options = {}, &callback)
-      @logger.info("Starting command run '#{command}' on #{targets.map(&:uri)}")
+      description = options.fetch('_description', "command '#{command}'")
+      log_action("Starting: #{description} on #{targets.map(&:uri)}")
       notify = proc { |event| @notifier.notify(callback, event) if callback }
       options = { '_run_as' => run_as }.merge(options) if run_as
 
       results = batch_execute(targets) do |transport, batch|
-        transport.batch_command(batch, command, options, &notify)
+        with_node_logging("Running command '#{command}'", batch) do
+          transport.batch_command(batch, command, options, &notify)
+        end
       end
 
-      @logger.info(summary('command', command, results))
+      log_action(summary(description, results))
       @notifier.shutdown
       results
     end
 
     def run_script(targets, script, arguments, options = {}, &callback)
-      @logger.info("Starting script run #{script} on #{targets.map(&:uri)}")
-      @logger.debug("Arguments: #{arguments}")
+      description = options.fetch('_description', "script #{script}")
+      log_action("Starting: #{description} on #{targets.map(&:uri)}")
+
       notify = proc { |event| @notifier.notify(callback, event) if callback }
       options = { '_run_as' => run_as }.merge(options) if run_as
 
       results = batch_execute(targets) do |transport, batch|
-        transport.batch_script(batch, script, arguments, options, &notify)
+        with_node_logging("Running script #{script} with '#{arguments}'", batch) do
+          transport.batch_script(batch, script, arguments, options, &notify)
+        end
       end
 
-      @logger.info(summary('script', script, results))
+      log_action(summary(description, results))
       @notifier.shutdown
       results
     end
 
     def run_task(targets, task, arguments, options = {}, &callback)
-      task_name = task.name
-      @logger.info("Starting task #{task_name} on #{targets.map(&:uri)}")
-      @logger.debug("Arguments: #{arguments} Input method: #{task.input_method}")
+      description = options.fetch('_description', "task #{task.name}")
+      log_action("Starting: #{description} on #{targets.map(&:uri)}")
+
       notify = proc { |event| @notifier.notify(callback, event) if callback }
       options = { '_run_as' => run_as }.merge(options) if run_as
 
       results = batch_execute(targets) do |transport, batch|
-        transport.batch_task(batch, task, arguments, options, &notify)
+        with_node_logging("Running task #{task.name} with '#{arguments}' via #{task.input_method}", batch) do
+          transport.batch_task(batch, task, arguments, options, &notify)
+        end
       end
 
-      @logger.info(summary('task', task_name, results))
+      log_action(summary(description, results))
       @notifier.shutdown
       results
     end
 
     def file_upload(targets, source, destination, options = {}, &callback)
-      @logger.info("Starting file upload from #{source} to #{destination} on #{targets.map(&:uri)}")
+      description = options.fetch('_description', "file upload from #{source} to #{destination}")
+      log_action("Starting: #{description} on #{targets.map(&:uri)}")
       notify = proc { |event| @notifier.notify(callback, event) if callback }
       options = { '_run_as' => run_as }.merge(options) if run_as
 
       results = batch_execute(targets) do |transport, batch|
-        transport.batch_upload(batch, source, destination, options, &notify)
+        with_node_logging("Uploading file #{source} to #{destination}", batch) do
+          transport.batch_upload(batch, source, destination, options, &notify)
+        end
       end
 
-      @logger.info(summary('upload', source, results))
+      log_action(summary(description, results))
       @notifier.shutdown
       results
     end
-
-    def puppetdb_client
-      return @puppetdb_client if @puppetdb_client
-      puppetdb_config = Bolt::PuppetDB::Config.new(nil, @config.puppetdb)
-      @puppetdb_client = Bolt::PuppetDB::Client.from_config(puppetdb_config)
-    end
-
-    def puppetdb_fact(certnames)
-      puppetdb_client.facts_for_node(certnames)
-    rescue StandardError => e
-      raise Bolt::CLIError, "Could not retrieve targets from PuppetDB: #{e}"
-    end
   end
 end

data/lib/bolt/inventory.rb

@@ -138,6 +138,10 @@ module Bolt
       conf.update_from_inventory(data['config'])
       conf.validate
 
+      unless target.protocol.nil? || Bolt::TRANSPORTS.include?(target.protocol.to_sym)
+        raise Bolt::UnknownTransportError.new(target.protocol, target.uri)
+      end
+
       target.update_conf(conf.transport_conf)
     end
     private :update_target

data/lib/bolt/pal.rb

@@ -12,14 +12,15 @@ module Bolt
       # Nothing works without initialized this global state. Reinitializing
       # is safe and in practice only happen in tests
       self.class.load_puppet
-      self.class.configure_logging(config[:log_level])
+      self.class.configure_logging
+      # This makes sure we don't accidentally create puppet dirs
+      with_puppet_settings { |_| nil }
 
       @config = config
     end
 
     # Puppet logging is global so this is class method to avoid confusion
-    def self.configure_logging(log_level)
-      Puppet[:log_level] = log_level == :debug ? 'debug' : 'notice'
+    def self.configure_logging
       Puppet::Util::Log.newdestination(:console)
     end
 
@@ -40,10 +41,6 @@ module Bolt
 
       # Now that puppet is loaded we can include puppet mixins in data types
       Bolt::ResultSet.include_iterable
-
-      unless Puppet.settings.global_defaults_initialized?
-        Puppet.initialize_settings
-      end
     end
 
     # Create a top-level alias for TargetSpec so that users don't have to
@@ -98,12 +95,15 @@ module Bolt
       r
     end
 
-    def with_bolt_executor(executor, inventory, &block)
-      Puppet.override({ bolt_executor: executor, bolt_inventory: inventory }, &block)
+    def with_bolt_executor(executor, inventory, pdb_client = nil, &block)
+      Puppet.override({ bolt_executor: executor, bolt_inventory: inventory, bolt_pdb_client: pdb_client }, &block)
     end
 
-    def in_plan_compiler(executor, inventory)
-      with_bolt_executor(executor, inventory) do
+    def in_plan_compiler(executor, inventory, pdb_client)
+      with_bolt_executor(executor, inventory, pdb_client) do
+        # TODO: remove this call and see if anything breaks when
+        # settings dirs don't actually exist. Plans shouldn't
+        # actually be using them.
         with_puppet_settings do
           in_bolt_compiler do |compiler|
             yield compiler
@@ -219,14 +219,14 @@ module Bolt
       plan_info
     end
 
-    def run_task(task_name, targets, params, executor, inventory, &eventblock)
+    def run_task(task_name, targets, params, executor, inventory, description = nil, &eventblock)
       in_task_compiler(executor, inventory) do |compiler|
-        compiler.call_function('run_task', task_name, targets, params, &eventblock)
+        compiler.call_function('run_task', task_name, targets, description, params, &eventblock)
       end
     end
 
-    def run_plan(plan_name, params, executor = nil, inventory = nil)
-      in_plan_compiler(executor, inventory) do |compiler|
+    def run_plan(plan_name, params, executor = nil, inventory = nil, pdb_client = nil)
+      in_plan_compiler(executor, inventory, pdb_client) do |compiler|
         r = compiler.call_function('run_plan', plan_name, params)
         Bolt::PuppetError.convert_puppet_errors(r)
       end

data/lib/bolt/puppetdb/client.rb

@@ -55,27 +55,21 @@ module Bolt
       def facts_for_node(certnames)
         return {} if certnames.empty? || certnames.nil?
 
-        # This inits a hash of {certname1 => {}, certname2 => {}} etc.
-        output = Hash[certnames.product([{}])]
-
         certnames.uniq!
         name_query = certnames.map { |c| ["=", "certname", c] }
         name_query.insert(0, "or")
         body = JSON.generate(query: name_query)
 
-        response = http_client.post("#{@uri}/pdb/query/v4/facts", body: body, header: headers)
+        response = http_client.post("#{@uri}/pdb/query/v4/inventory", body: body, header: headers)
         if response.code != 200
           raise Bolt::PuppetDBError, "Failed to query PuppetDB: #{response.body}"
         else
           parsed = JSON.parse(response.body)
         end
 
-        # Parse the data
-        parsed&.each do |f|
-          output[f['certname']][f['name']] = f['value']
+        parsed&.each_with_object({}) do |node, coll|
+          coll[node['certname']] = node['facts']
         end
-
-        output
       end
 
       def http_client

data/lib/bolt/result.rb

@@ -68,6 +68,11 @@ module Bolt
       new(target, message: "Uploaded '#{source}' to '#{target.host}:#{destination}'")
     end
 
+    # Satisfies the Puppet datatypes API
+    def self.from_asserted_args(target, value)
+      new(target, value: value)
+    end
+
     def initialize(target, error: nil, message: nil, value: nil)
       @target = target
       @value = value || {}

data/lib/bolt/transport/orch.rb

@@ -38,14 +38,16 @@ module Bolt
         OrchestratorClient.new(client_opts, true)
       end
 
-      def build_request(targets, task, arguments)
-        { task: task.name,
-          environment: targets.first.options["task-environment"],
-          noop: arguments['_noop'],
-          params: arguments.reject { |k, _| k == '_noop' },
-          scope: {
-            nodes: targets.map(&:host)
-          } }
+      def build_request(targets, task, arguments, description = nil)
+        body = { task: task.name,
+                 environment: targets.first.options["task-environment"],
+                 noop: arguments['_noop'],
+                 params: arguments.reject { |k, _| k == '_noop' },
+                 scope: {
+                   nodes: targets.map(&:host)
+                 } }
+        body[:description] = description if description
+        body
       end
 
       def process_run_results(targets, results)
@@ -75,11 +77,15 @@ module Bolt
         end
       end
 
-      def batch_command(targets, command, _options = {}, &callback)
+      def batch_command(targets, command, options = {}, &callback)
+        params = {
+          action: 'command',
+          command: command
+        }
         results = run_task_job(targets,
                                BOLT_MOCK_TASK,
-                               action: 'command',
-                               command: command,
+                               params,
+                               options,
                                &callback)
         callback ||= proc {}
         results.map! { |result| unwrap_bolt_result(result.target, result) }
@@ -88,7 +94,7 @@ module Bolt
         end
       end
 
-      def batch_script(targets, script, arguments, _options = {}, &callback)
+      def batch_script(targets, script, arguments, options = {}, &callback)
         content = File.open(script, &:read)
         content = Base64.encode64(content)
         params = {
@@ -97,14 +103,14 @@ module Bolt
           arguments: arguments
         }
         callback ||= proc {}
-        results = run_task_job(targets, BOLT_MOCK_TASK, params, &callback)
+        results = run_task_job(targets, BOLT_MOCK_TASK, params, options, &callback)
         results.map! { |result| unwrap_bolt_result(result.target, result) }
         results.each do |result|
           callback.call(type: :node_result, result: result)
         end
       end
 
-      def batch_upload(targets, source, destination, _options = {}, &callback)
+      def batch_upload(targets, source, destination, options = {}, &callback)
         content = File.open(source, &:read)
         content = Base64.encode64(content)
         mode = File.stat(source).mode
@@ -115,7 +121,7 @@ module Bolt
           mode: mode
         }
         callback ||= proc {}
-        results = run_task_job(targets, BOLT_MOCK_TASK, params, &callback)
+        results = run_task_job(targets, BOLT_MOCK_TASK, params, options, &callback)
         results.map! do |result|
           if result.error_hash
             result
@@ -136,8 +142,8 @@ module Bolt
         end.values
       end
 
-      def run_task_job(targets, task, arguments)
-        body = build_request(targets, task, arguments)
+      def run_task_job(targets, task, arguments, options)
+        body = build_request(targets, task, arguments, options['_description'])
 
         targets.each do |target|
           yield(type: :node_start, target: target) if block_given?
@@ -158,9 +164,9 @@ module Bolt
         end
       end
 
-      def batch_task(targets, task, arguments, _options = {}, &callback)
+      def batch_task(targets, task, arguments, options = {}, &callback)
         callback ||= proc {}
-        results = run_task_job(targets, task, arguments, &callback)
+        results = run_task_job(targets, task, arguments, options, &callback)
         results.each do |result|
           callback.call(type: :node_result, result: result)
         end

data/lib/bolt/transport/winrm.rb

@@ -83,6 +83,7 @@ try
 }
 catch
 {
+  Write-Error $_.Exception
   exit 1
 }
           PS
@@ -124,10 +125,10 @@ catch
 $private:taskArgs = Get-ContentAsJson (
   $utf8.GetString([System.Convert]::FromBase64String('#{Base64.encode64(JSON.dump(arguments))}'))
 )
-try { & "#{remote_path}" @taskArgs } catch { exit 1 }
+try { & "#{remote_path}" @taskArgs } catch { Write-Error $_.Exception; exit 1 }
               PS
                 else
-                  conn.execute(%(try { & "#{remote_path}" } catch { exit 1 }))
+                  conn.execute(%(try { & "#{remote_path}" } catch { Write-Error $_.Exception; exit 1 }))
                 end
               else
                 path, args = *process_from_extension(remote_path)

data/lib/bolt/util/on_access.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Bolt
+  module Util
+    class OnAccess
+      def initialize(&block)
+        @constructor = block
+        @obj = nil
+      end
+
+      # If a method is called and we haven't constructed the object,
+      # construct it. Then pass the call to the object.
+      # rubocop:disable Style/MethodMissing
+      def method_missing(method, *args, &block)
+        if @obj.nil?
+          @obj = @constructor.call
+        end
+
+        @obj.send(method, *args, &block)
+      end
+      # rubocop:enable Style/MethodMissing
+    end
+  end
+end

data/lib/bolt/version.rb

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