bolt 0.15.0 → 0.16.0

data/lib/bolt/node/orch.rb

@@ -43,7 +43,7 @@ module Bolt
       end
     end
 
-    def run_task(task, _input_method, arguments)
+    def run_task(task, _input_method, arguments, _options = nil)
       body = { task: task_name_from_path(task),
                environment: @orch_task_environment,
                noop: arguments['_noop'],
@@ -88,12 +88,12 @@ module Bolt
       Bolt::Result.for_command(@target, result.value['stdout'], result.value['stderr'], result.value['exit_code'])
     end
 
-    def run_command(command, options = {})
+    def run_command(command, _options = nil)
       result = run_task(BOLT_MOCK_FILE,
                         'stdin',
                         action: 'command',
                         command: command,
-                        options: options)
+                        options: {})
       unwrap_bolt_result(result)
     end
 
@@ -112,7 +112,7 @@ module Bolt
       result
     end
 
-    def run_script(script, arguments)
+    def run_script(script, arguments, _options = nil)
       content = File.open(script, &:read)
       content = Base64.encode64(content)
       params = {

data/lib/bolt/node/ssh.rb

@@ -15,10 +15,25 @@ module Bolt
       }
     end
 
+    def initialize(target, **kwargs)
+      super(target, **kwargs)
+      @conf_run_as = @run_as
+    end
+
     def protocol
       'ssh'
     end
 
+    if !!File::ALT_SEPARATOR
+      require 'ffi'
+      module Win
+        extend FFI::Library
+        ffi_lib 'user32'
+        ffi_convention :stdcall
+        attach_function :FindWindow, :FindWindowW, %i[buffer_in buffer_in], :int
+      end
+    end
+
     def connect
       transport_logger = Logging.logger[Net::SSH]
       transport_logger.level = :warn
@@ -30,13 +45,29 @@ module Bolt
       options[:port] = @target.port if @target.port
       options[:password] = @password if @password
       options[:keys] = @key if @key
-      options[:verify_host_key] = if @insecure
-                                    Net::SSH::Verifiers::Lenient.new
-                                  else
+      options[:verify_host_key] = if @host_key_check
                                     Net::SSH::Verifiers::Secure.new
+                                  else
+                                    Net::SSH::Verifiers::Lenient.new
                                   end
       options[:timeout] = @connect_timeout if @connect_timeout
 
+      # Mirroring:
+      # https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/agent.rb#L80
+      # https://github.com/net-ssh/net-ssh/blob/master/lib/net/ssh/authentication/pageant.rb#L403
+      if defined?(UNIXSocket) && UNIXSocket
+        if ENV['SSH_AUTH_SOCK'].to_s.empty?
+          @logger.debug { "Disabling use_agent in net-ssh: ssh-agent is not available" }
+          options[:use_agent] = false
+        end
+      elsif !!File::ALT_SEPARATOR
+        pageant_wide = 'Pageant'.encode('UTF-16LE')
+        if Win.FindWindow(pageant_wide, pageant_wide).to_i == 0
+          @logger.debug { "Disabling use_agent in net-ssh: pageant process not running" }
+          options[:use_agent] = false
+        end
+      end
+
       @session = Net::SSH.start(@target.host, @user, options)
       @logger.debug { "Opened session" }
     rescue Net::SSH::AuthenticationFailed => e
@@ -163,8 +194,6 @@ module Bolt
     def upload(source, destination)
       write_remote_file(source, destination)
       Bolt::Result.for_upload(@target, source, destination)
-    rescue StandardError => e
-      Bolt::Result.from_exception(@target, e)
     end
 
     def write_remote_file(source, destination)
@@ -253,28 +282,27 @@ SCRIPT
       end
     end
 
-    def run_command(command)
+    def run_command(command, options = {})
+      @run_as = options['_run_as'] || @conf_run_as
       output = execute(command, sudoable: true)
       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(@target, e)
+    ensure
+      @run_as = @conf_run_as
     end
 
-    def run_script(script, arguments)
+    def run_script(script, arguments, options = {})
+      @run_as = options['_run_as'] || @conf_run_as
       with_remote_file(script) do |remote_path|
         output = execute("'#{remote_path}' #{Shellwords.join(arguments)}",
                          sudoable: true)
         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(@target, e)
+    ensure
+      @run_as = @conf_run_as
     end
 
-    def run_task(task, input_method, arguments)
+    def run_task(task, input_method, arguments, options = {})
+      @run_as = options['_run_as'] || @conf_run_as
       export_args = {}
       stdin, output = nil
 
@@ -304,11 +332,8 @@ SCRIPT
       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(@target, e)
+    ensure
+      @run_as = @conf_run_as
     end
   end
 end

data/lib/bolt/node/winrm.rb

@@ -15,7 +15,7 @@ module Bolt
     HTTPS_PORT = 5986
 
     def port
-      default_port = @insecure ? HTTP_PORT : HTTPS_PORT
+      default_port = @ssl ? HTTPS_PORT : HTTP_PORT
       @target.port || default_port
     end
 
@@ -26,12 +26,12 @@ module Bolt
     end
 
     def connect
-      if @insecure
-        scheme = 'http'
-        transport = :negotiate
-      else
+      if @ssl
         scheme = 'https'
         transport = :ssl
+      else
+        scheme = 'http'
+        transport = :negotiate
       end
       endpoint = "#{scheme}://#{@target.host}:#{port}/wsman"
       options = { endpoint: endpoint,
@@ -54,8 +54,8 @@ module Bolt
     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"
+      if @ssl && port == HTTPS_PORT
+        theres_your_problem = "\nUse --no-ssl 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}#{theres_your_problem}",
@@ -68,7 +68,7 @@ module Bolt
       )
     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
+      if @ssl && port == HTTP_PORT
         theres_your_problem = "\nAre you using SSL to connect to a non-SSL port?"
       end
       raise Bolt::Node::ConnectError.new(
@@ -396,6 +396,7 @@ PS
       end
       result_output
     end
+    private :execute
 
     # 10 minutes in seconds
     DEFAULT_EXECUTION_TIMEOUT = 10 * 60
@@ -463,9 +464,6 @@ PS
     def upload(source, destination)
       write_remote_file(source, destination)
       Bolt::Result.for_upload(@target, source, destination)
-    # TODO: we should rely on the executor for this
-    rescue StandardError => ex
-      Bolt::Result.from_exception(@target, ex)
     end
 
     def write_remote_file(source, destination)
@@ -510,15 +508,12 @@ PS
       end
     end
 
-    def run_command(command)
+    def run_command(command, _options = nil)
       output = execute(command)
       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(@target, e)
     end
 
-    def run_script(script, arguments)
+    def run_script(script, arguments, _options = nil)
       with_remote_file(script) do |remote_path|
         if powershell_file?(remote_path)
           mapped_args = arguments.map do |a|
@@ -547,12 +542,9 @@ catch
         end
         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(@target, e)
     end
 
-    def run_task(task, input_method, arguments)
+    def run_task(task, input_method, arguments, _options = nil)
       if STDIN_METHODS.include?(input_method)
         stdin = JSON.dump(arguments)
       end
@@ -591,9 +583,6 @@ try { & "#{remote_path}" @taskArgs } catch { exit 1 }
                               output.stderr.string,
                               output.exit_code)
       end
-    # TODO: we should rely on the executor for this
-    rescue StandardError => e
-      Bolt::Result.from_exception(@target, e)
     end
 
     def escape_arguments(arguments)

data/lib/bolt/outputter.rb

@@ -14,6 +14,15 @@ module Bolt
     def initialize(stream = $stdout)
       @stream = stream
     end
+
+    # This method replaces data types tha have the name 'Data'
+    # with the string 'Any'
+    # This was a problem when using 'bolt task show <task_name>'
+    def replace_data_type(params)
+      params.map do |_, v|
+        v['type'] = 'Any' if v['type'].to_s == 'Data'
+      end
+    end
   end
 end
 

data/lib/bolt/outputter/human.rb

@@ -101,13 +101,14 @@ module Bolt
         usage = "bolt task run --nodes, -n <node-name> #{task['name']}"
 
         if task['parameters']
+          replace_data_type(task['parameters'])
           task['parameters'].each do |k, v|
             pretty_params << "- #{k}: #{v['type']}\n"
             pretty_params << "    #{v['description']}\n" if v['description']
-            usage << if !v['type'].to_s.include? "Optional"
-                       " #{k}=<value>"
-                     else
+            usage << if v['type'].is_a?(Puppet::Pops::Types::POptionalType)
                        " [#{k}=<value>]"
+                     else
+                       " #{k}=<value>"
                      end
           end
         end
@@ -122,7 +123,35 @@ module Bolt
         @stream.puts(task_info)
       end
 
-      def print_plan(result)
+      # @param [Hash] A hash representing the plan
+      def print_plan_info(plan)
+        # Building lots of strings...
+        pretty_params = ""
+        plan_info = ""
+        usage = "bolt plan run #{plan['name']}"
+
+        if plan['parameters']
+          plan['parameters'].each do |p|
+            name = p['name']
+            pretty_params << "- #{name}: #{p['type']}\n"
+            usage << if p.include?('default_value')
+                       # TODO: print the default value when available
+                       " [#{name}=<value>]"
+                     else
+                       " #{name}=<value>"
+                     end
+          end
+        end
+
+        plan_info << "\n#{plan['name']}"
+        plan_info << "\n\n"
+        plan_info << "USAGE:\n#{usage}\n\n"
+        plan_info << "PARAMETERS:\n#{pretty_params}\n" if plan['parameters']
+        @stream.puts(plan_info)
+      end
+
+      # @param [Hash] A hash representing the plan result
+      def print_plan_result(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

data/lib/bolt/outputter/json.rb

@@ -42,10 +42,15 @@ module Bolt
       end
 
       def print_task_info(task)
+        replace_data_type(task['parameters'])
         @stream.puts task.to_json
       end
 
-      def print_plan(result)
+      def print_plan_info(plan)
+        @stream.puts plan.to_json
+      end
+
+      def print_plan_result(result)
         # Ruby JSON patches most objects to have a to_json method.
         @stream.puts result.to_json
       end

data/lib/bolt/pal.rb

@@ -1,17 +1,34 @@
-# TODO: This is currently used only for testing. I will refactor the CLI to use
-# this in a separate PR
+require 'bolt/executor'
+require 'bolt/error'
+
 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
+      # 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])
+
       @config = config
     end
 
-    # WARNING: Nothing in here works without calling this!
+    # 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'
+      Puppet::Util::Log.newdestination(:console)
+    end
+
     def self.load_puppet
+      if Gem.win_platform?
+        # Windows 'fix' for openssl behaving strangely. Prevents very slow operation
+        # of random_bytes later when establishing winrm connections from a Windows host.
+        # See https://github.com/rails/rails/issues/25805 for background.
+        require 'openssl'
+        OpenSSL::Random.random_bytes(1)
+      end
+
       begin
         require_relative '../../vendored/require_vendored'
       rescue LoadError
@@ -20,14 +37,6 @@ module Bolt
 
       # 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
@@ -41,8 +50,9 @@ module Bolt
             yield compiler
           rescue Puppet::PreformattedError => err
             # Puppet sometimes rescues exceptions notes the location and reraises
-            # For now return the original error.
-            if err.cause
+            # For now return the original error. Exception cause support was added in Ruby 2.1
+            # so we fall back to reporting the error we got for Ruby 2.0.
+            if err.respond_to?(:cause) && err.cause
               if err.cause.is_a? Bolt::Error
                 err.cause
               else
@@ -73,8 +83,7 @@ module Bolt
       Puppet.override(bolt_executor: executor, &block)
     end
 
-    def in_plan_compiler(noop)
-      executor = Bolt::Executor.new(@config, noop, true)
+    def in_plan_compiler(executor)
       with_bolt_executor(executor) do
         with_puppet_settings do |opts|
           in_bolt_compiler(opts) do |compiler|
@@ -84,10 +93,9 @@ module Bolt
       end
     end
 
-    def in_task_compiler(noop)
-      executor = Bolt::Executor.new(@config, noop)
+    def in_task_compiler(executor)
       with_bolt_executor(executor) do
-        in_bolt_compiler(opts) do |compiler|
+        in_bolt_compiler do |compiler|
           yield compiler
         end
       end
@@ -102,5 +110,64 @@ module Bolt
         yield cli
       end
     end
+
+    def list_tasks
+      in_bolt_compiler do |compiler|
+        tasks = compiler.list_tasks
+        tasks.map(&:name).sort.map do |task_name|
+          task_sig = compiler.task_signature(task_name)
+          [task_name, task_sig.task.description]
+        end
+      end
+    end
+
+    def get_task_info(task_name)
+      task = in_bolt_compiler do |compiler|
+        compiler.task_signature(task_name)
+      end
+      raise Bolt::CLIError, "Could not find task #{task_name} in your modulepath" if task.nil?
+      task.task_hash
+    end
+
+    def list_plans
+      in_bolt_compiler do |compiler|
+        compiler.list_plans.map { |plan| [plan.name] }.sort
+      end
+    end
+
+    def get_plan_info(plan_name)
+      plan = in_bolt_compiler do |compiler|
+        compiler.plan_signature(plan_name)
+      end
+      raise Bolt::CLIError, "Could not find plan #{plan_name} in your modulepath" if plan.nil?
+      elements = plan.params_type.elements
+      {
+        'name' => plan_name,
+        'parameters' =>
+          unless elements.nil? || elements.empty?
+            elements.map { |e|
+              p = {
+                'name' => e.name,
+                'type' => e.value_type
+              }
+              # TODO: when the default value can be obtained use the actual value instead of nil
+              p['default_value'] = nil if e.key_type.is_a?(Puppet::Pops::Types::POptionalType)
+              p
+            }
+          end
+      }
+    end
+
+    def run_task(object, targets, params, executor, &eventblock)
+      in_task_compiler(executor) do |compiler|
+        compiler.call_function('run_task', object, targets, params, &eventblock)
+      end
+    end
+
+    def run_plan(object, params, executor)
+      in_plan_compiler(executor) do |compiler|
+        compiler.call_function('run_plan', object, params)
+      end
+    end
   end
 end