bolt 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aa5ef349a62f61714a7ae4b664febe0a794a1acf
-  data.tar.gz: bd71a0e1d122717a98f35ec882fd90bc885067f4
+  metadata.gz: 8583fc13483530b30cda78e12c42f207e07995d7
+  data.tar.gz: 13ec2527cf65cac99c03e7db2bf718279c289751
 SHA512:
-  metadata.gz: ae08cc350289783f725460ada932ccda8431ccc33ed71c2cbd2680e0d2b125e41b0abe45acba8c7cf9170832afca19bd87bb5ce99d97f5afa9617ba73751e54a
-  data.tar.gz: 7cf3ed3887d53350ca23e28ff45ce890037593204eb68532aa8e6d9c0a842918513ff6be014d2379fe2f84cfe22caaff59913335386c5ec2e86a4a6c4fae3ece
+  metadata.gz: b3dcfd21a5279b2fdf9fa35b66ed39f7207674a8d0cfe284bea12990fec93c294159638a88b93544d7a5818a0c093bb2d07595509ce8e1f6211ed6d587f381de
+  data.tar.gz: e823df525ff7ef1c0726af8a9d17482df286a0fc3f3fb0088a4b6aa48667fb0fa556b4ea188ad24837bdd293057d8046b07f300317ca72371c8e074d1b6b4688

data/lib/bolt/cli.rb

@@ -11,6 +11,7 @@ require 'bolt/executor'
 require 'bolt/target'
 require 'bolt/outputter'
 require 'bolt/config'
+require 'bolt/pal'
 require 'io/console'
 
 module Bolt
@@ -34,6 +35,7 @@ Available subcommands:
     bolt task show <task>            Show documentation for task
     bolt task run <task> [params]    Run a Puppet task
     bolt plan show                   Show list of available plans
+    bolt plan show <plan>            Show details for plan
     bolt plan run <plan> [params]    Run a Puppet task plan
     bolt file upload <src> <dest>    Upload a local file
 
@@ -45,6 +47,7 @@ Usage: bolt task <action> <task> [options] [parameters]
 
 Available actions are:
     show                             Show list of available tasks
+    show <task>                      Show documentation for task
     run                              Run a Puppet task
 
 Parameters are of the form <parameter>=<value>.
@@ -75,6 +78,7 @@ Usage: bolt plan <action> <plan> [options] [parameters]
 
 Available actions are:
     show                             Show list of available plans
+    show <plan>                      Show details for plan
     run                              Run a Puppet task plan
 
 Parameters are of the form <parameter>=<value>.
@@ -130,7 +134,7 @@ HELP
                   '* Windows nodes must specify protocol with winrm://',
                   '* protocol is `ssh` by default, may be `ssh` or `winrm`',
                   '* port defaults to `22` for SSH',
-                  '* port defaults to `5985` or `5986` for WinRM, based on the --insecure setting') do |nodes|
+                  '* port defaults to `5985` or `5986` for WinRM, based on the --[no-]ssl setting') do |nodes|
             results[:nodes] += parse_nodes(nodes)
             results[:nodes].uniq!
           end
@@ -181,9 +185,13 @@ HELP
                 "Output format to use: human or json") do |format|
           results[:format] = format
         end
-        opts.on('-k', '--insecure',
-                "Whether to connect insecurely ") do |insecure|
-          results[:insecure] = insecure
+        opts.on('--[no-]host-key-check',
+                "Check host keys with SSH") do |host_key_check|
+          results[:host_key_check] = host_key_check
+        end
+        opts.on('--[no-]ssl',
+                "Use SSL with WinRM") do |ssl|
+          results[:ssl] = ssl
         end
         opts.on('--transport TRANSPORT', TRANSPORTS,
                 "Specify a default transport: #{TRANSPORTS.join(', ')}") do |t|
@@ -394,42 +402,35 @@ HELP
 
     def execute(options)
       if options[:mode] == 'plan' || options[:mode] == 'task'
-        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] = if @config[:log_level] == :debug
-                               'debug'
-                             else
-                               'notice'
-                             end
+        pal = Bolt::PAL.new(@config)
       end
 
       if options[:action] == 'show'
         if options[:mode] == 'task'
           if options[:object]
-            outputter.print_task_info(get_task_info(options[:object]))
+            outputter.print_task_info(pal.get_task_info(options[:object]))
           else
-            outputter.print_table(list_tasks)
+            outputter.print_table(pal.list_tasks)
             outputter.print_message("\nUse `bolt task show <task-name>` to view "\
-                                  "details and parameters for a specific "\
-                                  "task.")
+                                    "details and parameters for a specific task.")
           end
         elsif options[:mode] == 'plan'
-          outputter.print_table(list_plans)
+          if options[:object]
+            outputter.print_plan_info(pal.get_plan_info(options[:object]))
+          else
+            outputter.print_table(pal.list_plans)
+            outputter.print_message("\nUse `bolt plan show <plan-name>` to view "\
+                                    "details and parameters for a specific plan.")
+          end
         end
         return 0
       end
 
       if options[:mode] == 'plan'
         executor = Bolt::Executor.new(@config, options[:noop], true)
-        execute_plan(executor, options)
+        result = pal.run_plan(options[:object], options[:task_options], executor)
+        outputter.print_plan_result(result)
+        # An exception would have been raised if the plan failed
         code = 0
       else
         executor = Bolt::Executor.new(@config, options[:noop])
@@ -454,7 +455,10 @@ HELP
                 outputter.print_event(event)
               end
             when 'task'
-              execute_task(executor, options) do |event|
+              pal.run_task(options[:object],
+                           targets,
+                           options[:task_options],
+                           executor) do |event|
                 outputter.print_event(event)
               end
             when 'file'
@@ -480,28 +484,6 @@ HELP
       raise e
     end
 
-    def with_bolt_executor(executor, &block)
-      Puppet.override(bolt_executor: executor, &block)
-    end
-
-    def execute_task(executor, options, &block)
-      with_bolt_executor(executor) do
-        run_task(options[:object],
-                 options[:nodes],
-                 options[:task_options],
-                 &block)
-      end
-    end
-
-    def execute_plan(executor, options)
-      # Plans return null here?
-      result = with_bolt_executor(executor) do
-        run_plan(options[:object],
-                 options[:task_options])
-      end
-      outputter.print_plan(result)
-    end
-
     def validate_file(type, path)
       if path.nil?
         raise Bolt::CLIError, "A #{type} must be specified"
@@ -525,88 +507,5 @@ HELP
     def outputter
       @outputter ||= Bolt::Outputter.for_format(@config[:format])
     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. 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
-                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 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 list_plans
-      in_bolt_compiler do |compiler|
-        compiler.list_plans.map { |plan| [plan.name] }.sort
-      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 run_task(name, targets, args, &block)
-      args = args.merge('_catch_errors' => true)
-      in_bolt_compiler do |compiler|
-        compiler.call_function('run_task', name, targets, args, &block)
-      end
-    end
-
-    def run_plan(plan, args)
-      Dir.mktmpdir('bolt') do |dir|
-        cli = []
-        Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
-          cli << "--#{setting}" << dir
-        end
-        in_bolt_compiler(cli) do |compiler|
-          compiler.call_function('run_plan', plan, args)
-        end
-      end
-    end
   end
 end

data/lib/bolt/config.rb

@@ -18,17 +18,26 @@ module Bolt
       format: 'human'
     }.freeze
 
-    TRANSPORT_OPTIONS = %i[insecure password run_as sudo_password extensions
-                           key tty tmpdir user connect_timeout cacert
+    TRANSPORT_OPTIONS = %i[host_key_check password run_as sudo_password extensions
+                           ssl key tty tmpdir user connect_timeout cacert
                            token_file orch_task_environment service_url].freeze
 
     TRANSPORT_DEFAULTS = {
       connect_timeout: 10,
       orch_task_environment: 'production',
-      insecure: false,
       tty: false
     }.freeze
 
+    TRANSPORT_SPECIFIC_DEFAULTS = {
+      ssh: {
+        host_key_check: true
+      },
+      winrm: {
+        ssl: true
+      },
+      pcp: {}
+    }.freeze
+
     TRANSPORTS = %i[ssh winrm pcp].freeze
 
     def initialize(**kwargs)
@@ -46,6 +55,12 @@ module Bolt
             self[:transports][transport][k] = v
           end
         end
+
+        TRANSPORT_SPECIFIC_DEFAULTS[transport].each do |k, v|
+          unless self[:transports][transport].key? k
+            self[:transports][transport][k] = v
+          end
+        end
       end
     end
 
@@ -100,8 +115,8 @@ module Bolt
         if data['ssh']['private-key']
           self[:transports][:ssh][:key] = data['ssh']['private-key']
         end
-        if data['ssh']['insecure']
-          self[:transports][:ssh][:insecure] = data['ssh']['insecure']
+        if data['ssh'].key?('host-key-check')
+          self[:transports][:ssh][:host_key_check] = data['ssh']['host-key-check']
         end
         if data['ssh']['connect-timeout']
           self[:transports][:ssh][:connect_timeout] = data['ssh']['connect-timeout']
@@ -118,8 +133,8 @@ module Bolt
         if data['winrm']['connect-timeout']
           self[:transports][:winrm][:connect_timeout] = data['winrm']['connect-timeout']
         end
-        if data['winrm']['insecure']
-          self[:transports][:winrm][:insecure] = data['winrm']['insecure']
+        if data['winrm'].key?('ssl')
+          self[:transports][:winrm][:ssl] = data['winrm']['ssl']
         end
         if data['winrm']['tmpdir']
           self[:transports][:winrm][:tmpdir] = data['winrm']['tmpdir']
@@ -167,9 +182,20 @@ module Bolt
       end
 
       TRANSPORT_OPTIONS.each do |key|
-        # TODO: We should eventually make these transport specific
         TRANSPORTS.each do |transport|
-          self[:transports][transport][key] = options[key] if options[key]
+          unless %i[ssl host_key_check].any? { |k| k == key }
+            self[:transports][transport][key] = options[key] if options[key]
+            next
+          end
+          if key == :ssl && transport == :winrm
+            # this defaults to true so we need to check the presence of the key
+            self[:transports][transport][key] = options[key] if options.key?(key)
+            next
+          elsif key == :host_key_check && transport == :ssh
+            # this defaults to true so we need to check the presence of the key
+            self[:transports][transport][key] = options[key] if options.key?(key)
+            next
+          end
         end
       end
     end

data/lib/bolt/executor.rb

@@ -10,6 +10,7 @@ require 'bolt/result_set'
 module Bolt
   class Executor
     attr_reader :noop
+    attr_accessor :run_as
 
     def initialize(config = Bolt::Config.new, noop = nil, plan_logging = false)
       @config = config
@@ -21,6 +22,7 @@ module Bolt
       default_log_level = plan_logging ? :info : :notice
       @logger.level = @config[:log_level] || default_log_level
       @noop = noop
+      @run_as = nil
       @notifier = Bolt::Notifier.new
     end
 
@@ -79,14 +81,32 @@ module Bolt
     end
     private :summary
 
-    def run_command(targets, command)
+    def get_run_as(node, options)
+      if node.run_as.nil? && run_as
+        { '_run_as' => run_as }.merge(options)
+      else
+        options
+      end
+    end
+    private :get_run_as
+
+    def with_exception_handling(node)
+      yield
+    rescue StandardError => e
+      Bolt::Result.from_exception(node.target, e)
+    end
+    private :with_exception_handling
+
+    def run_command(targets, command, options = {})
       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)
+        node_result = with_exception_handling(node) do
+          node.run_command(command, get_run_as(node, options))
+        end
         @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end
@@ -94,7 +114,7 @@ module Bolt
       r
     end
 
-    def run_script(targets, script, arguments)
+    def run_script(targets, script, arguments, options = {})
       nodes = from_targets(targets)
       @logger.info("Starting script run #{script} on #{nodes.map(&:uri)}")
       @logger.debug("Arguments: #{arguments}")
@@ -102,7 +122,9 @@ module Bolt
 
       r = on(nodes, callback) do |node|
         @logger.debug { "Running script '#{script}' on #{node.uri}" }
-        node_result = node.run_script(script, arguments)
+        node_result = with_exception_handling(node) do
+          node.run_script(script, arguments, get_run_as(node, options))
+        end
         @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end
@@ -110,7 +132,7 @@ module Bolt
       r
     end
 
-    def run_task(targets, task, input_method, arguments)
+    def run_task(targets, task, input_method, arguments, options = {})
       nodes = from_targets(targets)
       @logger.info("Starting task #{task} on #{nodes.map(&:uri)}")
       @logger.debug("Arguments: #{arguments} Input method: #{input_method}")
@@ -118,7 +140,9 @@ module Bolt
 
       r = on(nodes, callback) do |node|
         @logger.debug { "Running task run '#{task}' on #{node.uri}" }
-        node_result = node.run_task(task, input_method, arguments)
+        node_result = with_exception_handling(node) do
+          node.run_task(task, input_method, arguments, get_run_as(node, options))
+        end
         @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end
@@ -133,7 +157,9 @@ module Bolt
 
       r = on(nodes, callback) do |node|
         @logger.debug { "Uploading: '#{source}' to #{destination} on #{node.uri}" }
-        node_result = node.upload(source, destination)
+        node_result = with_exception_handling(node) do
+          node.upload(source, destination)
+        end
         @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result
       end

data/lib/bolt/node.rb

@@ -22,7 +22,7 @@ module Bolt
 
     def self.initialize_transport(_logger); end
 
-    attr_reader :logger, :user, :password, :connect_timeout, :target
+    attr_reader :logger, :user, :password, :connect_timeout, :target, :run_as
 
     def initialize(target, config: Bolt::Config.new)
       @target = target
@@ -33,7 +33,8 @@ module Bolt
       @key = transport_conf[:key]
       @cacert = transport_conf[:cacert]
       @tty = transport_conf[:tty]
-      @insecure = transport_conf[:insecure]
+      @host_key_check = transport_conf[:host_key_check]
+      @ssl = transport_conf[:ssl]
       @connect_timeout = transport_conf[:connect_timeout]
       @sudo_password = transport_conf[:sudo_password]
       @run_as = transport_conf[:run_as]
@@ -49,6 +50,22 @@ module Bolt
     def uri
       @target.uri
     end
+
+    def upload(_source, _destination)
+      raise NotImplementedError, 'transports must implement upload(source, destination)'
+    end
+
+    def run_command(_command, _options = nil)
+      raise NotImplementedError, 'transports must implement run_command(command, options = nil)'
+    end
+
+    def run_script(_script, _arguments, _options = nil)
+      raise NotImplementedError, 'transports must implement run_script(script, arguments, options = nil)'
+    end
+
+    def run_task(_task, _input_method, _arguments, _options = nil)
+      raise NotImplementedError, 'transports must implement run_task(task, input_method, arguments, options = nil)'
+    end
   end
 end