bolt 0.14.0 → 0.15.0

data/lib/bolt/node/ssh.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'shellwords'
+require 'logging'
 require 'net/ssh'
 require 'net/scp'
 require 'bolt/node/output'
@@ -19,12 +20,14 @@ module Bolt
     end
 
     def connect
+      transport_logger = Logging.logger[Net::SSH]
+      transport_logger.level = :warn
       options = {
-        logger: @transport_logger,
+        logger: transport_logger,
         non_interactive: true
       }
 
-      options[:port] = @port if @port
+      options[:port] = @target.port if @target.port
       options[:password] = @password if @password
       options[:keys] = @key if @key
       options[:verify_host_key] = if @insecure
@@ -34,7 +37,7 @@ module Bolt
                                   end
       options[:timeout] = @connect_timeout if @connect_timeout
 
-      @session = Net::SSH.start(@host, @user, options)
+      @session = Net::SSH.start(@target.host, @user, options)
       @logger.debug { "Opened session" }
     rescue Net::SSH::AuthenticationFailed => e
       raise Bolt::Node::ConnectError.new(
@@ -43,17 +46,17 @@ module Bolt
       )
     rescue Net::SSH::HostKeyError => e
       raise Bolt::Node::ConnectError.new(
-        "Host key verification failed for #{@uri}: #{e.message}",
+        "Host key verification failed for #{uri}: #{e.message}",
         'HOST_KEY_ERROR'
       )
     rescue Net::SSH::ConnectionTimeout
       raise Bolt::Node::ConnectError.new(
-        "Timeout after #{@connect_timeout} seconds connecting to #{@uri}",
+        "Timeout after #{@connect_timeout} seconds connecting to #{uri}",
         'CONNECT_ERROR'
       )
     rescue StandardError => e
       raise Bolt::Node::ConnectError.new(
-        "Failed to connect to #{@uri}: #{e.message}",
+        "Failed to connect to #{uri}: #{e.message}",
         'CONNECT_ERROR'
       )
     end
@@ -77,20 +80,20 @@ module Bolt
           return true
         else
           raise Bolt::Node::EscalateError.new(
-            "Sudo password for user #{@user} was not provided for #{@uri}",
+            "Sudo password for user #{@user} was not provided for #{uri}",
             'NO_PASSWORD'
           )
         end
       elsif data =~ /^#{@user} is not in the sudoers file\./
         @logger.debug { data }
         raise Bolt::Node::EscalateError.new(
-          "User #{@user} does not have sudo permission on #{@uri}",
+          "User #{@user} does not have sudo permission on #{uri}",
           'SUDO_DENIED'
         )
       elsif data =~ /^Sorry, try again\./
         @logger.debug { data }
         raise Bolt::Node::EscalateError.new(
-          "Sudo password for user #{@user} not recognized on #{@uri}",
+          "Sudo password for user #{@user} not recognized on #{uri}",
           'BAD_PASSWORD'
         )
       end
@@ -157,11 +160,11 @@ module Bolt
       result_output
     end
 
-    def _upload(source, destination)
+    def upload(source, destination)
       write_remote_file(source, destination)
-      Bolt::Result.new
+      Bolt::Result.for_upload(@target, source, destination)
     rescue StandardError => e
-      Bolt::Result.from_exception(e)
+      Bolt::Result.from_exception(@target, e)
     end
 
     def write_remote_file(source, destination)
@@ -250,28 +253,28 @@ SCRIPT
       end
     end
 
-    def _run_command(command)
+    def run_command(command)
       output = execute(command, sudoable: true)
-      Bolt::CommandResult.from_output(output)
+      Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
     # TODO: We should be able to rely on the excutor for this but it will mean
     # a test refactor
     rescue StandardError => e
-      Bolt::Result.from_exception(e)
+      Bolt::Result.from_exception(@target, e)
     end
 
-    def _run_script(script, arguments)
+    def run_script(script, arguments)
       with_remote_file(script) do |remote_path|
         output = execute("'#{remote_path}' #{Shellwords.join(arguments)}",
                          sudoable: true)
-        Bolt::CommandResult.from_output(output)
+        Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
       end
     # TODO: We should be able to rely on the excutor for this but it will mean
     # a test refactor
     rescue StandardError => e
-      Bolt::Result.from_exception(e)
+      Bolt::Result.from_exception(@target, e)
     end
 
-    def _run_task(task, input_method, arguments)
+    def run_task(task, input_method, arguments)
       export_args = {}
       stdin, output = nil
 
@@ -298,12 +301,14 @@ SCRIPT
           output = execute(command, stdin: stdin)
         end
       end
-      Bolt::TaskResult.from_output(output)
+      Bolt::Result.for_task(@target, output.stdout.string,
+                            output.stderr.string,
+                            output.exit_code)
 
     # TODO: We should be able to rely on the excutor for this but it will mean
     # a test refactor
     rescue StandardError => e
-      Bolt::Result.from_exception(e)
+      Bolt::Result.from_exception(@target, e)
     end
   end
 end

data/lib/bolt/node/winrm.rb

@@ -1,5 +1,6 @@
 require 'winrm'
 require 'winrm-fs'
+require 'logging'
 require 'bolt/result'
 require 'base64'
 require 'set'
@@ -10,13 +11,16 @@ module Bolt
       'winrm'
     end
 
+    HTTP_PORT = 5985
+    HTTPS_PORT = 5986
+
     def port
-      default_port = @insecure ? 5985 : 5986
-      @port || default_port
+      default_port = @insecure ? HTTP_PORT : HTTPS_PORT
+      @target.port || default_port
     end
 
-    def initialize(host, port, user, password, **kwargs)
-      super(host, port, user, password, **kwargs)
+    def initialize(target, **kwargs)
+      super(target, **kwargs)
       @extensions = DEFAULT_EXTENSIONS.to_set.merge(@extensions || [])
       @logger.debug { "WinRM initialized for #{@extensions.to_a} extensions" }
     end
@@ -29,7 +33,7 @@ module Bolt
         scheme = 'https'
         transport = :ssl
       end
-      endpoint = "#{scheme}://#{host}:#{port}/wsman"
+      endpoint = "#{scheme}://#{@target.host}:#{port}/wsman"
       options = { endpoint: endpoint,
                   user: @user,
                   password: @password,
@@ -39,15 +43,22 @@ module Bolt
 
       Timeout.timeout(@connect_timeout) do
         @connection = ::WinRM::Connection.new(options)
-        @connection.logger = @transport_logger
+        transport_logger = Logging.logger[::WinRM]
+        transport_logger.level = :warn
+        @connection.logger = transport_logger
 
         @session = @connection.shell(:powershell)
         @session.run('$PSVersionTable.PSVersion')
         @logger.debug { "Opened session" }
       end
     rescue Timeout::Error
+      # If we're using the default port with SSL, a timeout probably means the
+      # host doesn't support SSL.
+      if !@insecure && port == HTTPS_PORT
+        theres_your_problem = "\nUse --insecure if this host isn't configured to use SSL for WinRM"
+      end
       raise Bolt::Node::ConnectError.new(
-        "Timeout after #{@connect_timeout} seconds connecting to #{endpoint}",
+        "Timeout after #{@connect_timeout} seconds connecting to #{endpoint}#{theres_your_problem}",
         'CONNECT_ERROR'
       )
     rescue ::WinRM::WinRMAuthorizationError
@@ -55,6 +66,15 @@ module Bolt
         "Authentication failed for #{endpoint}",
         'AUTH_ERROR'
       )
+    rescue OpenSSL::SSL::SSLError => e
+      # If we're using SSL with the default non-SSL port, mention that as a likely problem
+      if !@insecure && port == HTTP_PORT
+        theres_your_problem = "\nAre you using SSL to connect to a non-SSL port?"
+      end
+      raise Bolt::Node::ConnectError.new(
+        "Failed to connect to #{endpoint}: #{e.message}#{theres_your_problem}",
+        "CONNECT_ERROR"
+      )
     rescue StandardError => e
       raise Bolt::Node::ConnectError.new(
         "Failed to connect to #{endpoint}: #{e.message}",
@@ -440,12 +460,12 @@ PS
       end
     end
 
-    def _upload(source, destination)
+    def upload(source, destination)
       write_remote_file(source, destination)
-      Bolt::Result.new
+      Bolt::Result.for_upload(@target, source, destination)
     # TODO: we should rely on the executor for this
     rescue StandardError => ex
-      Bolt::Result.from_exception(ex)
+      Bolt::Result.from_exception(@target, ex)
     end
 
     def write_remote_file(source, destination)
@@ -490,15 +510,15 @@ PS
       end
     end
 
-    def _run_command(command)
+    def run_command(command)
       output = execute(command)
-      Bolt::CommandResult.from_output(output)
+      Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
     # TODO: we should rely on the executor for this
     rescue StandardError => e
-      Bolt::Result.from_exception(e)
+      Bolt::Result.from_exception(@target, e)
     end
 
-    def _run_script(script, arguments)
+    def run_script(script, arguments)
       with_remote_file(script) do |remote_path|
         if powershell_file?(remote_path)
           mapped_args = arguments.map do |a|
@@ -525,14 +545,14 @@ catch
           args += escape_arguments(arguments)
           output = execute_process(path, args)
         end
-        Bolt::CommandResult.from_output(output)
+        Bolt::Result.for_command(@target, output.stdout.string, output.stderr.string, output.exit_code)
       end
     # TODO: we should rely on the executor for this
     rescue StandardError => e
-      Bolt::Result.from_exception(e)
+      Bolt::Result.from_exception(@target, e)
     end
 
-    def _run_task(task, input_method, arguments)
+    def run_task(task, input_method, arguments)
       if STDIN_METHODS.include?(input_method)
         stdin = JSON.dump(arguments)
       end
@@ -567,11 +587,13 @@ try { & "#{remote_path}" @taskArgs } catch { exit 1 }
             path, args = *process_from_extension(remote_path)
             execute_process(path, args, stdin)
           end
-        Bolt::TaskResult.from_output(output)
+        Bolt::Result.for_task(@target, output.stdout.string,
+                              output.stderr.string,
+                              output.exit_code)
       end
     # TODO: we should rely on the executor for this
     rescue StandardError => e
-      Bolt::Result.from_exception(e)
+      Bolt::Result.from_exception(@target, e)
     end
 
     def escape_arguments(arguments)

data/lib/bolt/notifier.rb

@@ -6,9 +6,9 @@ module Bolt
       @executor = executor
     end
 
-    def notify(callback, node, result)
+    def notify(callback, event)
       @executor.post do
-        callback.call(node, result)
+        callback.call(event)
       end
     end
 

data/lib/bolt/outputter/human.rb

@@ -25,48 +25,48 @@ module Bolt
         string.sub(/\s\z/, '')
       end
 
-      def print_event(node, event)
+      def print_event(event)
         case event[:type]
         when :node_start
-          print_start(node)
+          print_start(event[:target])
         when :node_result
-          print_result(node, event[:result])
+          print_result(event[:result])
         end
       end
 
-      def print_start(node)
-        @stream.puts(colorize(:green, "Started on #{node.host}..."))
+      def print_start(target)
+        @stream.puts(colorize(:green, "Started on #{target.host}..."))
       end
 
-      def print_result(node, result)
+      def print_result(result)
         if result.success?
-          @stream.puts(colorize(:green, "Finished on #{node.host}:"))
+          @stream.puts(colorize(:green, "Finished on #{result.target.host}:"))
         else
-          @stream.puts(colorize(:red, "Failed on #{node.host}:"))
+          @stream.puts(colorize(:red, "Failed on #{result.target.host}:"))
         end
 
-        if result.error
-          if result.error['msg']
-            @stream.puts(colorize(:red, remove_trail(indent(2, result.error['msg']))))
-          else
-            @stream.puts(colorize(:red, remove_trail(indent(2, result.error))))
-          end
+        if result.error_hash
+          @stream.puts(colorize(:red, remove_trail(indent(2, result.error_hash['msg']))))
         end
 
         if result.message
           @stream.puts(remove_trail(indent(2, result.message)))
         end
 
-        if result.instance_of? Bolt::TaskResult
-          @stream.puts(indent(2, ::JSON.pretty_generate(result.value)))
-        elsif result.instance_of? Bolt::CommandResult
-          unless result.stdout.strip.empty?
-            @stream.puts(indent(2, "STDOUT:"))
-            @stream.puts(indent(4, result.stdout))
-          end
-          unless result.stderr.strip.empty?
-            @stream.puts(indent(2, "STDERR:"))
-            @stream.puts(indent(4, result.stderr))
+        # There is more information to output
+        if result.generic_value
+          # Use special handling if the result looks like a command or script result
+          if result.generic_value.keys == %w[stdout stderr exit_code]
+            unless result['stdout'].strip.empty?
+              @stream.puts(indent(2, "STDOUT:"))
+              @stream.puts(indent(4, result['stdout']))
+            end
+            unless result['stderr'].strip.empty?
+              @stream.puts(indent(2, "STDERR:"))
+              @stream.puts(indent(4, result['stderr']))
+            end
+          else
+            @stream.puts(indent(2, ::JSON.pretty_generate(result.generic_value)))
           end
         end
       end
@@ -123,13 +123,15 @@ module Bolt
       end
 
       def print_plan(result)
-        # If a hash or array, pretty-print as JSON
-        if result.is_a?(Hash) || result.is_a?(Array)
-          if result.empty?
-            # Avoids extra lines for an empty result
+        # If the object has a json representation display it
+        if result.respond_to?(:to_json)
+          # Guard against to_json methods that don't accept options
+          # and don't print empty results on multiple lines
+          if result.method(:to_json).arity == 0 ||
+             (result.respond_to?(:empty?) && result.empty?)
             @stream.puts(result.to_json)
           else
-            @stream.puts(::JSON.pretty_generate(result))
+            @stream.puts(::JSON.pretty_generate(result, quirks_mode: true))
           end
         else
           @stream.puts result.to_s
@@ -138,6 +140,9 @@ module Bolt
 
       def fatal_error(e)
         @stream.puts(colorize(:red, e.message))
+        if e.is_a? Bolt::RunFailure
+          @stream.puts ::JSON.pretty_generate(e.resultset)
+        end
       end
     end
 

data/lib/bolt/outputter/json.rb

@@ -15,22 +15,16 @@ module Bolt
         @object_open = true
       end
 
-      def print_event(node, event)
+      def print_event(event)
         case event[:type]
         when :node_result
-          print_result(node, event[:result])
+          print_result(event[:result])
         end
       end
 
-      def print_result(node, result)
-        item = {
-          name: node.uri,
-          status: result.success? ? 'success' : 'failure',
-          result: result.to_result
-        }
-
+      def print_result(result)
         @stream.puts ',' if @preceding_item
-        @stream.puts item.to_json
+        @stream.puts result.status_hash.to_json
         @preceding_item = true
       end
 

data/lib/bolt/pal.rb

@@ -0,0 +1,106 @@
+# TODO: This is currently used only for testing. I will refactor the CLI to use
+# this in a separate PR
+module Bolt
+  class PAL
+    BOLTLIB_PATH = File.join(__FILE__, '../../../modules')
+
+    def initialize(config)
+      # TODO: how should we manage state? Does noop go here?
+      # This allows us to copypaste from BOLT::CLI for now
+      @config = config
+    end
+
+    # WARNING: Nothing in here works without calling this!
+    def self.load_puppet
+      begin
+        require_relative '../../vendored/require_vendored'
+      rescue LoadError
+        raise Bolt::CLIError, "Puppet must be installed to execute tasks"
+      end
+
+      # Now that puppet is loaded we can include puppet mixins in data types
+      Bolt::ResultSet.include_iterable
+
+      Puppet::Util::Log.newdestination(:console)
+      Puppet[:log_level] = 'notice'
+      # Puppet[:log_level] = if @config[:log_level] == :debug
+      #                       'debug'
+      #                     else
+      #                       'notice'
+      #                     end
+    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(opts = [])
+      Puppet.initialize_settings(opts)
+      r = Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + @config[:modulepath], facts: {}) do |pal|
+        pal.with_script_compiler do |compiler|
+          begin
+            yield compiler
+          rescue Puppet::PreformattedError => err
+            # Puppet sometimes rescues exceptions notes the location and reraises
+            # For now return the original error.
+            if err.cause
+              if err.cause.is_a? Bolt::Error
+                err.cause
+              else
+                e = Bolt::CLIError.new(err.cause.message)
+                e.set_backtrace(err.cause.backtrace)
+                e
+              end
+            else
+              e = Bolt::CLIError.new(err.message)
+              e.set_backtrace(err.backtrace)
+              e
+            end
+          rescue StandardError => err
+            e = Bolt::CLIError.new(err.message)
+            e.set_backtrace(err.backtrace)
+            e
+          end
+        end
+      end
+
+      if r.is_a? StandardError
+        raise r
+      end
+      r
+    end
+
+    def with_bolt_executor(executor, &block)
+      Puppet.override(bolt_executor: executor, &block)
+    end
+
+    def in_plan_compiler(noop)
+      executor = Bolt::Executor.new(@config, noop, true)
+      with_bolt_executor(executor) do
+        with_puppet_settings do |opts|
+          in_bolt_compiler(opts) do |compiler|
+            yield compiler
+          end
+        end
+      end
+    end
+
+    def in_task_compiler(noop)
+      executor = Bolt::Executor.new(@config, noop)
+      with_bolt_executor(executor) do
+        in_bolt_compiler(opts) do |compiler|
+          yield compiler
+        end
+      end
+    end
+
+    def with_puppet_settings
+      Dir.mktmpdir('bolt') do |dir|
+        cli = []
+        Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
+          cli << "--#{setting}" << dir
+        end
+        yield cli
+      end
+    end
+  end
+end