bolt 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4990187d4d2da77d515fdbe3d840b415683d7082
-  data.tar.gz: 1eebdfd02969958314e3fa1b4ce0e03b6efc208c
+  metadata.gz: 4bf0d0dd4615b52385ed0e9322d17ecaee392951
+  data.tar.gz: 6d5c006a8e472c547a99a24c90769b041730c24f
 SHA512:
-  metadata.gz: 97ae71fbb805bc96980f1353eebcb458e528c74e9a9c1c94a33ffe0f7c6256058080e6052cee0909dcb06a84fea6cb764a59f47de86e1027df2ff06c9ac3e1f4
-  data.tar.gz: 4fa7f06bf895ab837451077997aa05bbc4b0291116a3be254cb9e4c600d5eb35da98b48fa349a32ca902b8f4849fa5d79d9bc44b05754a4dc6b46050d088b87b
+  metadata.gz: ec8f8eb029f0b7a35ee7bce810859c3d2c143ec25bf5ad08544e9a79a8dc28831f721d2fa6037c188ec874d57678eb80e6ae4d1c681e70a7a998d8f07f627e08
+  data.tar.gz: '09ea1f87c8b36045fd6e55837d89977a1106efec8882797dcd9a11297518ab845feedc766fb8a957b87f6c427168992695808eb5fea173c06878715b0e1379f9'

data/lib/bolt/cli.rb

@@ -30,7 +30,10 @@ Usage: bolt <subcommand> <action> [options]
 Available subcommands:
     bolt command run <command>       Run a command remotely
     bolt script run <script>         Upload a local script and run it remotely
+    bolt task show                   Show list of available tasks
+    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 run <plan> [params]    Run a Puppet task plan
     bolt file upload <src> <dest>    Upload a local file
 
@@ -41,6 +44,7 @@ HELP
 Usage: bolt task <action> <task> [options] [parameters]
 
 Available actions are:
+    show                             Show list of available tasks
     run                              Run a Puppet task
 
 Parameters are of the form <parameter>=<value>.
@@ -70,6 +74,7 @@ HELP
 Usage: bolt plan <action> <plan> [options] [parameters]
 
 Available actions are:
+    show                             Show list of available plans
     run                              Run a Puppet task plan
 
 Parameters are of the form <parameter>=<value>.
@@ -86,8 +91,11 @@ Available actions are:
 Available options are:
 HELP
 
-    MODES = %w[command script task plan file].freeze
-    ACTIONS = %w[run upload download].freeze
+    COMMANDS = { 'command' => %w[run],
+                 'script'  => %w[run],
+                 'task'    => %w[show run],
+                 'plan'    => %w[show run],
+                 'file'    => %w[upload] }.freeze
     TRANSPORTS = %w[ssh winrm pcp].freeze
     BOLTLIB_PATH = File.join(__FILE__, '../../../modules')
 
@@ -172,16 +180,16 @@ HELP
         end
         opts.on('--transport TRANSPORT', TRANSPORTS,
                 "Specify a default transport: #{TRANSPORTS.join(', ')}") do |t|
-          options[:transport] = t
+          results[:transport] = t
         end
         opts.on('--run-as USER',
                 "User to run as using privilege escalation") do |user|
-          options[:run_as] = user
+          results[:run_as] = user
         end
         opts.on('--sudo [PROGRAM]',
                 "Program to execute for privilege escalation. " \
                 "Currently only sudo is supported.") do |program|
-          options[:sudo] = program || 'sudo'
+          results[:sudo] = program || 'sudo'
         end
         opts.on('--sudo-password [PASSWORD]',
                 'Password for privilege escalation') do |password|
@@ -201,6 +209,10 @@ HELP
                      "Request a pseudo TTY on nodes that support it") do |tty|
           results[:tty] = tty
         end
+        opts.on_tail('--noop',
+                     "Execute a task that supports it in noop mode") do |_|
+          results[:noop] = true
+        end
         opts.on_tail('-h', '--help', 'Display help') do |_|
           results[:help] = true
         end
@@ -314,10 +326,10 @@ HELP
     end
 
     def validate(options)
-      unless MODES.include?(options[:mode])
+      unless COMMANDS.include?(options[:mode])
         raise Bolt::CLIError,
               "Expected subcommand '#{options[:mode]}' to be one of " \
-              "#{MODES.join(', ')}"
+              "#{COMMANDS.keys.join(', ')}"
       end
 
       if options[:action].nil?
@@ -325,10 +337,11 @@ HELP
               "Expected an action of the form 'bolt #{options[:mode]} <action>'"
       end
 
-      unless ACTIONS.include?(options[:action])
+      actions = COMMANDS[options[:mode]]
+      unless actions.include?(options[:action])
         raise Bolt::CLIError,
               "Expected action '#{options[:action]}' to be one of " \
-              "#{ACTIONS.join(', ')}"
+              "#{actions.join(', ')}"
       end
 
       if options[:mode] != 'file' && options[:mode] != 'script' &&
@@ -337,7 +350,7 @@ HELP
               "Unknown argument(s) #{options[:leftovers].join(', ')}"
       end
 
-      if %w[task plan].include?(options[:mode])
+      if %w[task plan].include?(options[:mode]) && options[:action] == 'run'
         if options[:object].nil?
           raise Bolt::CLIError, "Must specify a #{options[:mode]} to run"
         end
@@ -348,15 +361,20 @@ HELP
         end
       end
 
-      unless !options[:nodes].empty? || options[:mode] == 'plan'
+      if options[:nodes].empty? && options[:mode] != 'plan' && options[:action] != 'show'
         raise Bolt::CLIError, "Option '--nodes' must be specified"
       end
 
       if %w[task plan].include?(options[:mode]) && @config[:modulepath].nil?
         raise Bolt::CLIError,
-              "Option '--modulepath' must be specified when running" \
+              "Option '--modulepath' must be specified when using" \
               " a task or plan"
       end
+
+      if options[:noop] && (options[:mode] != 'task' || options[:action] != 'run')
+        raise Bolt::CLIError,
+              "Option '--noop' may only be specified when running a task"
+      end
     end
 
     def handle_parser_errors
@@ -383,7 +401,27 @@ HELP
                              end
       end
 
-      executor = Bolt::Executor.new(@config)
+      # ExecutionResult loaded here so that it can get puppet features if
+      # puppet is present
+      require 'bolt/execution_result'
+
+      if options[:action] == 'show'
+        if options[:mode] == 'task'
+          if options[:object]
+            outputter.print_task_info(get_task_info(options[:object]))
+          else
+            outputter.print_table(list_tasks)
+            outputter.print_message("\nUse `bolt task show <task-name>` to view "\
+                                  "details and parameters for a specific "\
+                                  "task.")
+          end
+        elsif options[:mode] == 'plan'
+          outputter.print_table(list_plans)
+        end
+        return
+      end
+
+      executor = Bolt::Executor.new(@config, options[:noop])
 
       if options[:mode] == 'plan'
         execute_plan(executor, options)
@@ -483,24 +521,82 @@ HELP
       @outputter ||= Bolt::Outputter.for_format(@config[:format])
     end
 
-    def run_task(name, nodes, args, &block)
-      parse_error = nil
-      Puppet.initialize_settings
+    def in_bolt_compiler(opts = [])
+      Puppet.initialize_settings(opts)
       Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + @config[:modulepath], facts: {}) do |pal|
         pal.with_script_compiler do |compiler|
-          begin
-            return compiler.call_function('run_task', name, nodes, args, &block)
-          rescue Puppet::ParseError => e
-            # we assume that the Puppet::ParseError is due to a problem with
-            # the task and/or its parameters, but since the with_script_compiler
-            # method rescues these errors and raises different ones instead,
-            # we save it in a local variable and raise it as Bolt::CLIError
-            # outside of the block
-            parse_error = e
+          yield compiler
+        end
+      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
+    rescue Puppet::Error
+      raise Bolt::CLIError, "Failure while reading task metadata"
+    end
+
+    def list_plans
+      in_bolt_compiler do |compiler|
+        compiler.list_plans.map { |plan| [plan.name] }.sort
+      end
+    rescue Puppet::Error
+      raise Bolt::CLIError, "Failure while reading plans"
+    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
+    rescue Puppet::Error
+      raise Bolt::CLIError, "Failure while reading task metadata"
+    end
+
+    def run_task(name, nodes, args, &block)
+      parse_error = nil
+      result = in_bolt_compiler do |compiler|
+        begin
+          compiler.call_function('run_task', name, nodes, args, &block)
+        rescue Puppet::ParseError => e
+          # we assume that the Puppet::ParseError is due to a problem with
+          # the task and/or its parameters, but since the with_script_compiler
+          # method rescues these errors and raises different ones instead,
+          # we save it in a local variable and raise it as Bolt::CLIError
+          # outside of the block
+          parse_error = e
+        end
+      end
+      raise Bolt::CLIError, parse_error.message if parse_error
+      result
+    end
+
+    # Expects to be called with a configured Puppet compiler or error.instance? will fail
+    def unwrap_execution_result(result)
+      if result.instance_of? Bolt::ExecutionResult
+        result.iterator.map do |node, output|
+          if output.is_a?(Puppet::DataTypes::Error)
+            # Get the original error hash used to initialize the Error type object.
+            result = output.partial_result || {}
+            result[:_error] = { msg: output.message,
+                                kind: output.kind,
+                                details: output.details,
+                                issue_code: output.issue_code }
+            { node: node, status: 'failed', result: result }
+          else
+            { node: node, status: 'finished', result: output }
           end
         end
+      else
+        result
       end
-      raise Bolt::CLIError, parse_error.message
     end
 
     def run_plan(plan, args)
@@ -509,11 +605,11 @@ HELP
         Puppet::Settings::REQUIRED_APP_SETTINGS.each do |setting|
           cli << "--#{setting}" << dir
         end
-        Puppet.initialize_settings(cli)
-        Puppet::Pal.in_tmp_environment('bolt', modulepath: [BOLTLIB_PATH] + @config[:modulepath], facts: {}) do |pal|
-          pal.with_script_compiler do |compiler|
-            compiler.call_function('run_plan', plan, args)
-          end
+        in_bolt_compiler(cli) do |compiler|
+          result = compiler.call_function('run_plan', plan, args)
+          # Querying ExecutionResult for failures currently requires a script compiler.
+          # Convert from an ExecutionResult to structured output that we can print.
+          unwrap_execution_result(result)
         end
       end
     end

data/lib/bolt/config.rb

@@ -1,5 +1,6 @@
 require 'logger'
 require 'yaml'
+require 'bolt/cli'
 
 module Bolt
   Config = Struct.new(
@@ -20,10 +21,13 @@ module Bolt
       log_destination: STDERR
     }.freeze
 
-    TRANSPORT_OPTIONS = %i[insecure password run_as sudo sudo_password key tty tmpdir user connect_timeout].freeze
+    TRANSPORT_OPTIONS = %i[insecure password run_as sudo sudo_password
+                           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
@@ -47,15 +51,23 @@ module Bolt
       end
     end
 
-    def default_path
-      path = ['.puppetlabs', 'bolt.yml']
-      root_path = '~'
-      File.join(root_path, *path)
+    def default_paths
+      root_path = File.expand_path(File.join('~', '.puppetlabs'))
+      [File.join(root_path, 'bolt.yaml'), File.join(root_path, 'bolt.yml')]
     end
 
     def read_config_file(path)
       path_passed = path
-      path ||= default_path
+      if path.nil?
+        found_default = default_paths.select { |p| File.exist?(p) }
+        if found_default.size > 1
+          logger = Logger.new(self[:log_destination])
+          logger.warn "Config files found at #{found_default.join(', ')}, using the first"
+        end
+        # Use first found, fall back to first default and try to load even if it didn't exist
+        path = found_default.first || default_paths.first
+      end
+
       path = File.expand_path(path)
       # safe_load doesn't work with psych in ruby 2.0
       # The user controls the configfile so this isn't a problem
@@ -106,9 +118,30 @@ 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']
+        end
         if data['winrm']['tmpdir']
           self[:transports][:winrm][:tmpdir] = data['winrm']['tmpdir']
         end
+        if data['winrm']['cacert']
+          self[:transports][:winrm][:cacert] = data['winrm']['cacert']
+        end
+      end
+
+      if data['pcp']
+        if data['pcp']['service-url']
+          self[:transports][:pcp][:service_url] = data['pcp']['service-url']
+        end
+        if data['pcp']['cacert']
+          self[:transports][:pcp][:cacert] = data['pcp']['cacert']
+        end
+        if data['pcp']['token-file']
+          self[:transports][:pcp][:token_file] = data['pcp']['token-file']
+        end
+        if data['pcp']['task-environment']
+          self[:transports][:pcp][:orch_task_environment] = data['pcp']['task-environment']
+        end
       end
     end
 

data/lib/bolt/execution_result.rb

@@ -0,0 +1,109 @@
+module Bolt
+  class ExecutionResult
+    if Object.const_defined?(:Puppet) && Puppet.const_defined?(:Pops)
+      include Puppet::Pops::Types::Iterable
+      include Puppet::Pops::Types::IteratorProducer
+
+      def iterator
+        tc = Puppet::Pops::Types::TypeFactory
+        Puppet::Pops::Types::Iterable.on(
+          @result_hash,
+          tc.tuple([tc.string, tc.data], Puppet::Pops::Types::PHashType::KEY_PAIR_TUPLE_SIZE)
+        )
+      end
+
+      def to_s
+        Puppet::Pops::Types::StringConverter.singleton.convert(self)
+      end
+    else
+      def iterator
+        @result_hash.each
+      end
+    end
+
+    # Creates a pure Data hash from a result hash returned from the Bolt::Executor
+    # @return [Hash{String => Data}] The data hash
+    def self.from_bolt(result_hash)
+      data_result = {}
+      result_hash.each_pair { |k, v| data_result[k.uri] = v.to_h }
+      new(data_result)
+    end
+
+    attr_reader :result_hash
+
+    def initialize(result_hash, final = false)
+      result_hash = convert_errors(result_hash) unless final
+      @result_hash = result_hash
+    end
+
+    def count
+      @result_hash.size
+    end
+
+    def empty
+      @result_hash.empty?
+    end
+    alias empty? empty
+
+    def error_nodes
+      result = {}
+      @result_hash.each_pair { |k, v| result[k] = v if v.is_a?(Error) }
+      self.class.new(result, true)
+    end
+
+    def names
+      @result_hash.keys
+    end
+
+    def ok
+      @result_hash.values.none? { |v| v.is_a?(Error) }
+    end
+    alias ok? ok
+
+    def ok_nodes
+      result = {}
+      @result_hash.each_pair { |k, v| result[k] = v unless v.is_a?(Error) }
+      self.class.new(result, true)
+    end
+
+    def [](node_uri)
+      @result_hash[node_uri]
+    end
+
+    def value(node_uri)
+      self[node_uri]
+    end
+
+    def values
+      @result_hash.values
+    end
+
+    def _pcore_init_hash
+      @result_hash
+    end
+
+    def eql?(other)
+      self.class == other.class && @result_hash == other.result_hash
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    private
+
+    def convert_errors(result_hash)
+      converted = {}
+      result_hash.each_pair { |k, v| converted[k] = convert_error(v) }
+      converted
+    end
+
+    def convert_error(value_or_error)
+      e = value_or_error['error']
+      v = value_or_error['value']
+      e.nil? ? v : Puppet::DataTypes::Error.new(e['msg'], e['kind'], e['issue_code'], v, e['details'])
+    end
+
+    EMPTY_RESULT = new({})
+  end
+end