bolt 0.14.0 → 0.15.0

data/lib/bolt/executor.rb

@@ -1,9 +1,11 @@
-require 'bolt/logger'
 require 'json'
 require 'concurrent'
+require 'logging'
 require 'bolt/result'
 require 'bolt/config'
 require 'bolt/notifier'
+require 'bolt/node'
+require 'bolt/result_set'
 
 module Bolt
   class Executor
@@ -11,20 +13,26 @@ module Bolt
 
     def initialize(config = Bolt::Config.new, noop = nil, plan_logging = false)
       @config = config
-      @logger = Logger.get_logger(progname: 'executor')
+      @logger = Logging.logger[self]
+
+      # 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
       @notifier = Bolt::Notifier.new
-      @plan_logging = plan_logging
     end
 
-    def from_uris(nodes)
-      nodes.map do |node|
-        Bolt::Node.from_uri(node, config: @config)
+    def from_targets(targets)
+      targets.map do |target|
+        Bolt::Node.from_target(target, config: @config)
       end
     end
+    private :from_targets
 
     def on(nodes, callback = nil)
-      results = Concurrent::Map.new
+      results = Concurrent::Array.new
 
       poolsize = [nodes.length, @config[:concurrency]].min
       pool = Concurrent::FixedThreadPool.new(poolsize)
@@ -38,11 +46,11 @@ module Bolt
         pool.post do
           result =
             begin
-              @notifier.notify(callback, node, type: :node_start) if callback
+              @notifier.notify(callback, type: :node_start, target: node.target) if callback
               node.connect
               yield node
             rescue StandardError => ex
-              Bolt::Result.from_exception(ex)
+              Bolt::Result.from_exception(node.target, ex)
             ensure
               begin
                 node.disconnect
@@ -50,11 +58,8 @@ module Bolt
                 @logger.info("Failed to close connection to #{node.uri} : #{ex.message}")
               end
             end
-          results[node] = result
-          if callback
-            @notifier.notify(callback, node, type: :node_result, result: result)
-          end
-          result
+          results.concat([result])
+          @notifier.notify(callback, type: :node_result, result: result) if callback
         end
       }
       pool.shutdown
@@ -62,84 +67,78 @@ module Bolt
 
       @notifier.shutdown
 
-      results_to_hash(results)
+      Bolt::ResultSet.new(results)
     end
+    private :on
 
     def summary(action, object, result)
-      fc = result.select { |_, r| r.error }.length
+      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}"
     end
+    private :summary
 
-    def run_command(nodes, command)
-      level = @plan_logging ? Logger::NOTICE : Logger::INFO
-      @logger.log(level, "Starting command run '#{command}' on #{nodes.map(&:uri)}")
+    def run_command(targets, command)
+      nodes = from_targets(targets)
+      @logger.info("Starting command run '#{command}' on #{nodes.map(&:uri)}")
       callback = block_given? ? Proc.new : nil
 
       r = on(nodes, callback) do |node|
         @logger.debug("Running command '#{command}' on #{node.uri}")
         node_result = node.run_command(command)
-        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.to_result)}")
+        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end
-      @logger.log(level, summary('command', command, r))
+      @logger.info(summary('command', command, r))
       r
     end
 
-    def run_script(nodes, script, arguments)
-      level = @plan_logging ? Logger::NOTICE : Logger::INFO
-      @logger.log(level, "Starting script run #{script} on #{nodes.map(&:uri)}")
+    def run_script(targets, script, arguments)
+      nodes = from_targets(targets)
+      @logger.info("Starting script run #{script} on #{nodes.map(&:uri)}")
       @logger.debug("Arguments: #{arguments}")
       callback = block_given? ? Proc.new : nil
 
       r = on(nodes, callback) do |node|
         @logger.debug { "Running script '#{script}' on #{node.uri}" }
         node_result = node.run_script(script, arguments)
-        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.to_result)}")
+        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end
-      @logger.log(level, summary('script', script, r))
+      @logger.info(summary('script', script, r))
       r
     end
 
-    def run_task(nodes, task, input_method, arguments)
-      level = @plan_logging ? Logger::NOTICE : Logger::INFO
-      @logger.log(level, "Starting task #{task} on #{nodes.map(&:uri)}")
+    def run_task(targets, task, input_method, arguments)
+      nodes = from_targets(targets)
+      @logger.info("Starting task #{task} on #{nodes.map(&:uri)}")
       @logger.debug("Arguments: #{arguments} Input method: #{input_method}")
       callback = block_given? ? Proc.new : nil
 
       r = on(nodes, callback) do |node|
         @logger.debug { "Running task run '#{task}' on #{node.uri}" }
         node_result = node.run_task(task, input_method, arguments)
-        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.to_result)}")
+        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end
-      @logger.log(level, summary('task', task, r))
+      @logger.info(summary('task', task, r))
       r
     end
 
-    def file_upload(nodes, source, destination)
-      level = @plan_logging ? Logger::NOTICE : Logger::INFO
-      @logger.log(level, "Starting file upload from #{source} to #{destination} on #{nodes.map(&:uri)}")
+    def file_upload(targets, source, destination)
+      nodes = from_targets(targets)
+      @logger.info("Starting file upload from #{source} to #{destination} on #{nodes.map(&:uri)}")
       callback = block_given? ? Proc.new : nil
 
       r = on(nodes, callback) do |node|
-        @logger.debug { "Uploading: '#{source}' to #{node.uri}" }
+        @logger.debug { "Uploading: '#{source}' to #{destination} on #{node.uri}" }
         node_result = node.upload(source, destination)
-        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.to_result)}")
+        @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end
-      @logger.log(level, summary('upload', source, r))
+      @logger.info(summary('upload', source, r))
       r
     end
-
-    private
-
-    def results_to_hash(results)
-      result_hash = {}
-      results.each_pair { |k, v| result_hash[k] = v }
-      result_hash
-    end
   end
 end

data/lib/bolt/logger.rb

@@ -1,56 +1,32 @@
-require 'logger'
-require 'bolt/formatter'
-
-class Logger
-  send :remove_const, 'SEV_LABEL'
-
-  SEV_LABEL = {
-    0 => 'DEBUG',
-    1 => 'INFO',
-    2 => 'NOTICE',
-    3 => 'WARN',
-    4 => 'ERROR',
-    5 => 'FATAL',
-    6 => 'ANY'
-  }.freeze
-
-  module Severity
-    levels = %w[WARN ERROR FATAL ANY]
-    levels.each do |level|
-      send(:remove_const, level) if const_defined?(level)
+require 'logging'
+
+module Bolt
+  module Logger
+    # 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 it's already been initialized
+      return if Logging.initialized?
+
+      Logging.init :debug, :info, :notice, :warn, :error, :fatal, :any
+      Logging.appenders.stderr(
+        'stderr',
+        layout: Logging.layouts.pattern(
+          pattern: '%d %-6l %c: %m\n',
+          date_pattern: '%Y-%m-%dT%H:%M:%S.%6N'
+        )
+      )
+      root_logger = Logging.logger[:root]
+      root_logger.add_appenders :stderr
+      root_logger.level = :notice
     end
-    NOTICE = 2
-    WARN = 3
-    ERROR = 4
-    FATAL = 5
-    ANY = 6
-  end
-
-  def notice(progname = nil, &block)
-    add(NOTICE, nil, progname, &block)
-  end
 
-  def notice?
-    @level <= NOTICE
-  end
-
-  # rubocop:disable Style/ClassVars
-  @@config = {
-    log_destination: STDERR,
-    log_level: NOTICE
-  }
-
-  # Not thread safe call only during startup
-  def self.configure(config)
-    @@config[:log_level] = config[:log_level] if config[:log_level]
-  end
-
-  def self.get_logger(**conf)
-    conf = @@config.merge(conf)
-    logger = new(conf[:log_destination])
-    logger.level = conf[:log_level]
-    logger.progname = conf[:progname] if conf[:progname]
-    logger.formatter = Bolt::Formatter.new
-    logger
+    def self.reset_logging
+      Logging.reset
+    end
   end
 end

data/lib/bolt/node.rb

@@ -1,17 +1,15 @@
-require 'bolt/logger'
-require 'bolt/node_uri'
 require 'bolt/result'
 require 'bolt/config'
 require 'bolt/target'
+require 'logging'
 
 module Bolt
   class Node
     STDIN_METHODS       = %w[both stdin].freeze
     ENVIRONMENT_METHODS = %w[both environment].freeze
 
-    def self.from_uri(uri_string, **kwargs)
-      uri = NodeURI.new(uri_string, kwargs[:config][:transport])
-      klass = case uri.scheme
+    def self.from_target(target, **kwargs)
+      klass = case target.protocol || kwargs[:config][:transport]
               when 'winrm'
                 Bolt::WinRM
               when 'pcp'
@@ -19,27 +17,19 @@ module Bolt
               else
                 Bolt::SSH
               end
-      klass.new(uri.hostname,
-                uri.port,
-                uri.user,
-                uri.password,
-                uri: uri_string,
-                **kwargs)
+      klass.new(target, **kwargs)
     end
 
     def self.initialize_transport(_logger); end
 
-    attr_reader :logger, :host, :port, :uri, :user, :password, :connect_timeout
+    attr_reader :logger, :user, :password, :connect_timeout, :target
 
-    def initialize(host, port = nil, user = nil, password = nil, uri: nil,
-                   config: Bolt::Config.new)
-      @host = host
-      @port = port
-      @uri = uri
+    def initialize(target, config: Bolt::Config.new)
+      @target = target
 
       transport_conf = config[:transports][protocol.to_sym]
-      @user = user || transport_conf[:user]
-      @password = password || transport_conf[:password]
+      @user = @target.user || transport_conf[:user]
+      @password = @target.password || transport_conf[:password]
       @key = transport_conf[:key]
       @cacert = transport_conf[:cacert]
       @tty = transport_conf[:tty]
@@ -53,30 +43,11 @@ module Bolt
       @orch_task_environment = transport_conf[:orch_task_environment]
       @extensions = transport_conf[:extensions]
 
-      @logger = Logger.get_logger(progname: @host)
-      @transport_logger = Logger.get_logger(progname: @host, log_level: Logger::WARN)
+      @logger = Logging.logger[@target.host]
     end
 
-    def upload(source, destination)
-      @logger.debug { "Uploading #{source} to #{destination}" }
-      result = _upload(source, destination)
-      if result.success?
-        Bolt::Result.new(nil, "Uploaded '#{source}' to '#{host}:#{destination}'")
-      else
-        result
-      end
-    end
-
-    def run_command(command)
-      _run_command(command)
-    end
-
-    def run_script(script, arguments)
-      _run_script(script, arguments)
-    end
-
-    def run_task(task, input_method, arguments)
-      _run_task(task, input_method, arguments)
+    def uri
+      @target.uri
     end
   end
 end

data/lib/bolt/node/orch.rb

@@ -43,13 +43,13 @@ module Bolt
       end
     end
 
-    def _run_task(task, _input_method, arguments)
+    def run_task(task, _input_method, arguments)
       body = { task: task_name_from_path(task),
                environment: @orch_task_environment,
                noop: arguments['_noop'],
                params: arguments.reject { |k, _| k == '_noop' },
                scope: {
-                 nodes: [@host]
+                 nodes: [@target.host]
                } }
       # Should we handle errors here or let them propagate?
       results = client.run_task(body)
@@ -57,53 +57,47 @@ module Bolt
       state = node_result['state']
       result = node_result['result']
 
-      if state == 'finished'
-        exit_code = 0
+      # If it's finished or already has a proper error simply pass it to the
+      # the result otherwise make sure an error is generated
+      if state == 'finished' || result['_error']
+        Bolt::Result.new(@target, value: result)
       elsif state == 'skipped'
-        return Bolt::TaskResult.new(
-          JSON.dump(
-            '_error' => {
-              'kind' => 'puppetlabs.tasks/skipped-node',
-              'msg' => "Node #{@host} was skipped",
-              'details' => {}
-            }
-          ),
-          nil,
-          nil
+        Bolt::Result.new(
+          @target,
+          value: { '_error' => {
+            'kind' => 'puppetlabs.tasks/skipped-node',
+            'msg' => "Node #{@target.host} was skipped",
+            'details' => {}
+          } }
         )
       else
-        # Try to extract the exit_code from _error
-        begin
-          exit_code = result['_error']['details']['exit_code'] || 'unknown'
-        rescue NoMethodError
-          exit_code = 'unknown'
-        end
+        # Make a generic error with a unkown exit_code
+        Bolt::Result.for_task(@target, result.to_json, '', 'unknown')
       end
-      Bolt::TaskResult.new(result.to_json, "", exit_code)
     end
 
     # run_task generates a result that makes sense for a generic task which
     # needs to be unwrapped to extract stdout/stderr/exitcode.
     #
     def unwrap_bolt_result(result)
-      if result.error
+      if result.error_hash
         # something went wrong return the failure
         return result
       end
 
-      Bolt::CommandResult.new(result.value['stdout'], result.value['stderr'], result.value['exit_code'])
+      Bolt::Result.for_command(@target, result.value['stdout'], result.value['stderr'], result.value['exit_code'])
     end
 
-    def _run_command(command, options = {})
-      result = _run_task(BOLT_MOCK_FILE,
-                         'stdin',
-                         action: 'command',
-                         command: command,
-                         options: options)
+    def run_command(command, options = {})
+      result = run_task(BOLT_MOCK_FILE,
+                        'stdin',
+                        action: 'command',
+                        command: command,
+                        options: options)
       unwrap_bolt_result(result)
     end
 
-    def _upload(source, destination)
+    def upload(source, destination)
       content = File.open(source, &:read)
       content = Base64.encode64(content)
       mode = File.stat(source).mode
@@ -113,12 +107,12 @@ module Bolt
         content: content,
         mode: mode
       }
-      result = _run_task(BOLT_MOCK_FILE, 'stdin', params)
-      result = Bolt::Result.new unless result.error
+      result = run_task(BOLT_MOCK_FILE, 'stdin', params)
+      result = Bolt::Result.for_upload(@target, source, destination) unless result.error_hash
       result
     end
 
-    def _run_script(script, arguments)
+    def run_script(script, arguments)
       content = File.open(script, &:read)
       content = Base64.encode64(content)
       params = {
@@ -126,7 +120,7 @@ module Bolt
         content: content,
         arguments: arguments
       }
-      unwrap_bolt_result(_run_task(BOLT_MOCK_FILE, 'stdin', params))
+      unwrap_bolt_result(run_task(BOLT_MOCK_FILE, 'stdin', params))
     end
   end
 end