bolt 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e58990a30c659e55cfa6a9414baddbb4e5f7f4f
-  data.tar.gz: 0eb8ae695aa463156484836b7d439531eaac7a79
+  metadata.gz: 4f2d9129386dc3a217bf9af861ea74bce3ab86dd
+  data.tar.gz: d5dc3738a58d8eb61b014f1fb4f51d06bf604558
 SHA512:
-  metadata.gz: 3b974ec47cff910a4c70681503abb723b7d9dc8f0182b6b85028bf35ae487c4bec2a6cb5015165708d74ac822f7c28e04777db2c9e74969d15e5390712aef26e
-  data.tar.gz: c43c7890532c703505517d150fb546899f7b4992d91846eb889bcb86ae6885dc62b0fe88d0b2d91aabc31ba82463b05a8a9eff2c10e8c071071ee8f153874c97
+  metadata.gz: 55407e4f976256368488f4c17a6d1cfacd909f7334052a152f89868f7d4103e7dc7e3e10344bbc8b2dfcfb39805fab908bc89ae40cc83c3d056bd70b62436fbc
+  data.tar.gz: '03808cd73c73b89ad00583e05539ca669302a30011c2c051b8abfd6947685c1269472c8a62b5a4def7bdcf94cec3902f4521a00743804146e05754faf29ab17a'

data/exe/bolt

@@ -10,6 +10,6 @@ begin
 rescue Bolt::CLIExit
   exit
 rescue Bolt::CLIError => e
-  $stderr.puts e.message
+  warn e.message
   exit e.error_code
 end

data/lib/bolt.rb

@@ -3,11 +3,8 @@ require 'logger'
 module Bolt
   class << self
     attr_accessor :log_level
-    attr_accessor :config
   end
 
-  @config = {}
-
   require 'bolt/executor'
   require 'bolt/node'
 end

data/lib/bolt/cli.rb

@@ -6,6 +6,8 @@ require 'json'
 require 'bolt/node'
 require 'bolt/version'
 require 'bolt/executor'
+require 'bolt/config'
+require 'io/console'
 
 module Bolt
   class CLIError < RuntimeError
@@ -26,18 +28,18 @@ 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 run <task> [params]    Run a Puppet Task
-    bolt plan run <plan> [params]    Run a plan
+    bolt task run <task> [params]    Run a Puppet task
+    bolt plan run <plan> [params]    Run a Puppet task plan
     bolt file upload <src> <dest>    Upload a local file
 
 where [options] are:
 HELP
 
     TASK_HELP = <<-HELP.freeze
-Usage: bolt task <action> [options] [parameters]
+Usage: bolt task <action> <task> [options] [parameters]
 
 Available actions are:
-    run                              Run a task
+    run                              Run a Puppet task
 
 Parameters are of the form <parameter>=<value>.
 
@@ -66,7 +68,7 @@ HELP
 Usage: bolt plan <action> <plan> [options] [parameters]
 
 Available actions are:
-    run                              Run a plan
+    run                              Run a Puppet task plan
 
 Parameters are of the form <parameter>=<value>.
 
@@ -98,24 +100,33 @@ HELP
     def create_option_parser(results)
       OptionParser.new('') do |opts|
         opts.on(
-          '-n', '--nodes x,y,z', Array,
+          '-n', '--nodes NODES',
           'Node(s) to connect to in URI format [protocol://]host[:port]',
           'Eg. --nodes bolt.puppet.com',
           'Eg. --nodes localhost,ssh://nix.com:2222,winrm://windows.puppet.com',
           "\n",
+          '* NODES can either be comma-separated, \'@<file>\' to read',
+          '* nodes from a file, or \'-\' to read from stdin',
           '* Windows nodes must specify protocol with winrm://',
           '* protocol is `ssh` by default, may be `ssh` or `winrm`',
           '* port is `22` by default for SSH, `5985` for winrm (Optional)'
         ) do |nodes|
-          results[:nodes] = nodes
+          results[:nodes] = parse_nodes(nodes)
         end
         opts.on('-u', '--user USER',
                 "User to authenticate as (Optional)") do |user|
           results[:user] = user
         end
-        opts.on('-p', '--password PASSWORD',
-                "Password to authenticate as (Optional)") do |password|
-          results[:password] = password
+        opts.on('-p', '--password [PASSWORD]',
+                'Password to authenticate with (Optional).',
+                'Omit the value to prompt for the password.') do |password|
+          if password.nil?
+            STDOUT.print "Please enter your password: "
+            results[:password] = STDIN.noecho(&:gets).chomp
+            STDOUT.puts
+          else
+            results[:password] = password
+          end
         end
         results[:concurrency] = 100
         opts.on('-c', '--concurrency CONCURRENCY', Integer,
@@ -130,6 +141,11 @@ HELP
                 "Parameters to a task or plan") do |params|
           results[:task_options] = parse_params(params)
         end
+        results[:insecure] = false
+        opts.on('-k', '--insecure',
+                "Whether to connect insecurely ") do |insecure|
+          results[:insecure] = insecure
+        end
         opts.on_tail('--[no-]tty',
                      "Request a pseudo TTY on nodes that support it") do |tty|
           results[:tty] = tty
@@ -138,10 +154,10 @@ HELP
           results[:help] = true
         end
         opts.on_tail('--verbose', 'Display verbose logging') do |_|
-          Bolt.log_level = Logger::INFO
+          results[:verbose] = true
         end
         opts.on_tail('--debug', 'Display debug logging') do |_|
-          Bolt.log_level = Logger::DEBUG
+          results[:debug] = true
         end
         opts.on_tail('--version', 'Display the version') do |_|
           puts Bolt::VERSION
@@ -171,6 +187,12 @@ HELP
       options[:action] = remaining.shift
       options[:object] = remaining.shift
 
+      if options[:debug]
+        Bolt.log_level = Logger::DEBUG
+      elsif options[:verbose]
+        Bolt.log_level = Logger::INFO
+      end
+
       if options[:help]
         print_help(options[:mode])
         raise Bolt::CLIExit
@@ -212,6 +234,11 @@ HELP
       puts parser.help
     end
 
+    def parse_nodes(nodes)
+      list = get_arg_input(nodes)
+      list.split(/[[:space:],]+/).reject(&:empty?).uniq
+    end
+
     def parse_params(params)
       json = get_arg_input(params)
       JSON.parse(json)
@@ -238,12 +265,15 @@ HELP
 
     def validate(options)
       unless MODES.include?(options[:mode])
-        raise Bolt::CLIError, "Expected mode to be one of #{MODES.join(', ')}"
+        raise Bolt::CLIError,
+              "Expected subcommand '#{options[:mode]}' to be one of " \
+              "#{MODES.join(', ')}"
       end
 
       unless ACTIONS.include?(options[:action])
         raise Bolt::CLIError,
-              "Expected action to be one of #{ACTIONS.join(', ')}"
+              "Expected action '#{options[:action]}' to be one of " \
+              "#{ACTIONS.join(', ')}"
       end
 
       if options[:mode] != 'file' && !options[:leftovers].empty?
@@ -280,23 +310,26 @@ HELP
                              end
       end
 
+      config = Bolt::Config.new(concurrency: options[:concurrency],
+                                user: options[:user],
+                                password: options[:password],
+                                tty: options[:tty],
+                                insecure: options[:insecure])
+      executor = Bolt::Executor.new(config)
+
       if options[:mode] == 'plan'
-        execute_plan(options)
+        execute_plan(executor, options)
       else
-        nodes = options[:nodes].map do |node|
-          Bolt::Node.from_uri(node, options[:user], options[:password],
-                              tty: options[:tty])
-        end
+        nodes = executor.from_uris(options[:nodes])
 
         results = nil
         elapsed_time = Benchmark.realtime do
-          executor = Bolt::Executor.new(nodes, options[:concurrency])
           results =
             case options[:mode]
             when 'command'
-              executor.run_command(options[:object])
+              executor.run_command(nodes, options[:object])
             when 'script'
-              executor.run_script(options[:object])
+              executor.run_script(nodes, options[:object])
             when 'task'
               task_name = options[:object]
 
@@ -304,7 +337,9 @@ HELP
               input_method = metadata['input_method']
 
               input_method ||= 'both'
-              executor.run_task(path, input_method, options[:task_options])
+              executor.run_task(
+                nodes, path, input_method, options[:task_options]
+              )
             when 'file'
               src = options[:object]
               dest = options[:leftovers].first
@@ -315,7 +350,7 @@ HELP
                 raise Bolt::CLIError, "The source file '#{src}' does not exist"
               end
 
-              executor.file_upload(src, dest)
+              executor.file_upload(nodes, src, dest)
             end
         end
 
@@ -323,16 +358,15 @@ HELP
       end
     end
 
-    def execute_plan(options)
-      Bolt.config = options
-      begin
-        result = run_plan(options[:object],
-                          options[:task_options],
-                          options[:modules])
-      rescue Puppet::Error
-        raise Bolt::CLIError, "Exiting because of an error in Puppet code"
+    def execute_plan(executor, options)
+      result = Puppet.override(bolt_executor: executor) do
+        run_plan(options[:object],
+                 options[:task_options],
+                 options[:modules])
       end
       puts result
+    rescue Puppet::Error
+      raise Bolt::CLIError, "Exiting because of an error in Puppet code"
     end
 
     def colorize(result, stream)

data/lib/bolt/config.rb

@@ -0,0 +1,19 @@
+module Bolt
+  Config = Struct.new(:concurrency,
+                      :user,
+                      :password,
+                      :tty,
+                      :insecure) do
+
+    DEFAULTS = {
+      concurrency: 100,
+      tty: false,
+      insecure: false
+    }.freeze
+
+    def initialize(**kwargs)
+      super()
+      DEFAULTS.merge(kwargs).each { |k, v| self[k] = v }
+    end
+  end
+end

data/lib/bolt/executor.rb

@@ -1,27 +1,32 @@
 require 'concurrent'
 require 'bolt/result'
+require 'bolt/config'
 
 module Bolt
   class Executor
-    def self.from_uris(uris)
-      new(uris.map { |uri| Bolt::Node.from_uri(uri) })
+    def initialize(config = Bolt::Config.new)
+      @config = config
     end
 
-    def initialize(nodes, max_threads = 100)
-      @nodes = nodes
-      @poolsize = [nodes.length, max_threads].min
+    def from_uris(nodes)
+      nodes.map do |node|
+        Bolt::Node.from_uri(node, config: @config)
+      end
     end
 
-    def on_each
+    def on(nodes)
       results = Concurrent::Map.new
 
-      pool = Concurrent::FixedThreadPool.new(@poolsize)
-      @nodes.each { |node|
+      poolsize = [nodes.length, @config[:concurrency]].min
+      pool = Concurrent::FixedThreadPool.new(poolsize)
+      nodes.each { |node|
         pool.post do
           results[node] =
             begin
               node.connect
               yield node
+            rescue Bolt::Node::BaseError => ex
+              Bolt::ErrorResult.new(ex.message, ex.issue_code, ex.kind)
             rescue StandardError => ex
               node.logger.error(ex)
               Bolt::ExceptionResult.new(ex)
@@ -36,26 +41,26 @@ module Bolt
       results_to_hash(results)
     end
 
-    def run_command(command)
-      on_each do |node|
+    def run_command(nodes, command)
+      on(nodes) do |node|
         node.run_command(command)
       end
     end
 
-    def run_script(script)
-      on_each do |node|
+    def run_script(nodes, script)
+      on(nodes) do |node|
         node.run_script(script)
       end
     end
 
-    def run_task(task, input_method, arguments)
-      on_each do |node|
+    def run_task(nodes, task, input_method, arguments)
+      on(nodes) do |node|
         node.run_task(task, input_method, arguments)
       end
     end
 
-    def file_upload(source, destination)
-      on_each do |node|
+    def file_upload(nodes, source, destination)
+      on(nodes) do |node|
         node.upload(source, destination)
       end
     end

data/lib/bolt/node.rb

@@ -2,14 +2,14 @@ require 'logger'
 require 'bolt/node_uri'
 require 'bolt/node/formatter'
 require 'bolt/result'
+require 'bolt/config'
 
 module Bolt
   class Node
     STDIN_METHODS       = %w[both stdin].freeze
     ENVIRONMENT_METHODS = %w[both environment].freeze
 
-    def self.from_uri(uri_string, default_user = nil, default_password = nil,
-                      **kwargs)
+    def self.from_uri(uri_string, **kwargs)
       uri = NodeURI.new(uri_string)
       klass = case uri.scheme
               when 'winrm'
@@ -21,21 +21,23 @@ module Bolt
               end
       klass.new(uri.hostname,
                 uri.port,
-                uri.user || default_user || Bolt.config[:user],
-                uri.password || default_password || Bolt.config[:password],
-                uri: uri_string, **kwargs)
+                uri.user,
+                uri.password,
+                uri: uri_string,
+                **kwargs)
     end
 
     attr_reader :logger, :host, :uri, :user, :password
 
-    def initialize(host, port = nil, user = nil,
-                   password = nil, tty: false, uri: nil,
+    def initialize(host, port = nil, user = nil, password = nil, uri: nil,
+                   config: Bolt::Config.new,
                    log_level: Bolt.log_level || Logger::WARN)
       @host = host
-      @user = user
       @port = port
-      @password = password
-      @tty = tty
+      @user = user || config[:user]
+      @password = password || config[:password]
+      @tty = config[:tty]
+      @insecure = config[:insecure]
       @uri = uri
 
       @logger = init_logger(level: log_level)
@@ -74,6 +76,7 @@ module Bolt
   end
 end
 
+require 'bolt/node/errors'
 require 'bolt/node/ssh'
 require 'bolt/node/winrm'
 require 'bolt/node/orch'

data/lib/bolt/node/errors.rb

@@ -0,0 +1,22 @@
+module Bolt
+  class Node
+    class BaseError < StandardError
+      attr_reader :issue_code
+
+      def initialize(message, issue_code)
+        super(message)
+        @issue_code = issue_code
+      end
+
+      def kind
+        'puppetlabs.tasks/node-error'
+      end
+    end
+
+    class ConnectError < BaseError
+      def kind
+        'puppetlabs.tasks/connect-error'
+      end
+    end
+  end
+end

data/lib/bolt/node/ssh.rb

@@ -6,13 +6,36 @@ require 'bolt/node/result'
 module Bolt
   class SSH < Node
     def connect
-      options = { logger: @transport_logger,
-                  non_interactive: true }
+      options = {
+        logger: @transport_logger,
+        non_interactive: true
+      }
+
       options[:port] = @port if @port
       options[:password] = @password if @password
+      options[:verify_host_key] = if @insecure
+                                    Net::SSH::Verifiers::Lenient.new
+                                  else
+                                    Net::SSH::Verifiers::Secure.new
+                                  end
 
       @session = Net::SSH.start(@host, @user, options)
       @logger.debug { "Opened session" }
+    rescue Net::SSH::AuthenticationFailed => e
+      raise Bolt::Node::ConnectError.new(
+        e.message,
+        'AUTH_ERROR'
+      )
+    rescue Net::SSH::HostKeyError => e
+      raise Bolt::Node::ConnectError.new(
+        "Host key verification failed for #{@uri}: #{e.message}",
+        'HOST_KEY_ERROR'
+      )
+    rescue StandardError => e
+      raise Bolt::Node::ConnectError.new(
+        "Failed to connect to #{@uri}: #{e.message}",
+        'CONNECT_ERROR'
+      )
     end
 
     def disconnect