bolt 0.16.0 → 0.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8583fc13483530b30cda78e12c42f207e07995d7
-  data.tar.gz: 13ec2527cf65cac99c03e7db2bf718279c289751
+  metadata.gz: 4c145190f4fb70b998c8fd501a368940c2d2db3c
+  data.tar.gz: 45949da83f3903d369a71f88730e8ef7413cdff7
 SHA512:
-  metadata.gz: b3dcfd21a5279b2fdf9fa35b66ed39f7207674a8d0cfe284bea12990fec93c294159638a88b93544d7a5818a0c093bb2d07595509ce8e1f6211ed6d587f381de
-  data.tar.gz: e823df525ff7ef1c0726af8a9d17482df286a0fc3f3fb0088a4b6aa48667fb0fa556b4ea188ad24837bdd293057d8046b07f300317ca72371c8e074d1b6b4688
+  metadata.gz: 4597004b2108d16ab6aaf401e0b5160ef711ce27fe487b1996457f3b007ffc522c438b6df3a4b540b7e7566b9bc3794ecee4474400dbf21393b132b5abf99134
+  data.tar.gz: fe62dba570d0e11ed31e2be2e490a8eaa347485edf9adca4798e6c731ae892f48ad767f6f3493f1f54f42df7468b091c9a8db057e6bc65b2037eb607817b3152

data/lib/bolt/cli.rb

@@ -1,18 +1,19 @@
 require 'uri'
-require 'optparse'
 require 'benchmark'
 require 'json'
+require 'io/console'
 require 'logging'
-require 'bolt/logger'
-require 'bolt/node'
-require 'bolt/version'
+require 'optparse'
+require 'bolt/config'
 require 'bolt/error'
 require 'bolt/executor'
-require 'bolt/target'
+require 'bolt/inventory'
+require 'bolt/logger'
+require 'bolt/node'
 require 'bolt/outputter'
-require 'bolt/config'
 require 'bolt/pal'
-require 'io/console'
+require 'bolt/target'
+require 'bolt/version'
 
 module Bolt
   class CLIError < Bolt::Error
@@ -135,8 +136,7 @@ HELP
                   '* 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 --[no-]ssl setting') do |nodes|
-            results[:nodes] += parse_nodes(nodes)
-            results[:nodes].uniq!
+            results[:nodes] << get_arg_input(nodes).split(/[[:space:],]+/).reject(&:empty?)
           end
         end
         opts.on('-u', '--user USER',
@@ -215,6 +215,10 @@ HELP
                 'Specify where to load the config file from') do |path|
           results[:configfile] = path
         end
+        opts.on('--inventoryfile INVENTORY_PATH',
+                'Specify where to load the invenotry file from') do |path|
+          results[:inventoryfile] = path
+        end
         opts.on_tail('--[no-]tty',
                      "Request a pseudo TTY on nodes that support it") do |tty|
           results[:tty] = tty
@@ -311,11 +315,6 @@ HELP
       raise e
     end
 
-    def parse_nodes(nodes)
-      list = get_arg_input(nodes)
-      Target.parse_urls(list)
-    end
-
     def parse_params(params)
       json = get_arg_input(params)
       JSON.parse(json)
@@ -401,6 +400,15 @@ HELP
     end
 
     def execute(options)
+      message = nil
+
+      handler = Signal.trap :INT do |signo|
+        @logger.info(
+          "Exiting after receiving SIG#{Signal.signame(signo)} signal." << (message ? ' ' << message : '')
+        )
+        exit!
+      end
+
       if options[:mode] == 'plan' || options[:mode] == 'task'
         pal = Bolt::PAL.new(@config)
       end
@@ -426,15 +434,18 @@ HELP
         return 0
       end
 
+      inventory = Bolt::Inventory.from_config(@config)
+      message = 'There may be processes left executing on some nodes.'
+
       if options[:mode] == 'plan'
         executor = Bolt::Executor.new(@config, options[:noop], true)
-        result = pal.run_plan(options[:object], options[:task_options], executor)
+        result = pal.run_plan(options[:object], options[:task_options], executor, inventory)
         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])
-        targets = options[:nodes]
+        targets = inventory.get_targets(options[:nodes])
 
         results = nil
         outputter.print_head
@@ -458,7 +469,8 @@ HELP
               pal.run_task(options[:object],
                            targets,
                            options[:task_options],
-                           executor) do |event|
+                           executor,
+                           inventory) do |event|
                 outputter.print_event(event)
               end
             when 'file'
@@ -482,6 +494,9 @@ HELP
     rescue Bolt::Error => e
       outputter.fatal_error(e)
       raise e
+    ensure
+      # restore original signal handler
+      Signal.trap :INT, handler if handler
     end
 
     def validate_file(type, path)

data/lib/bolt/config.rb

@@ -6,6 +6,7 @@ module Bolt
   Config = Struct.new(
     :concurrency,
     :format,
+    :inventoryfile,
     :log_level,
     :modulepath,
     :transport,
@@ -69,40 +70,15 @@ module Bolt
       [File.join(root_path, 'bolt.yaml'), File.join(root_path, 'bolt.yml')]
     end
 
-    def read_config_file(path)
-      path_passed = path
-      if path.nil?
-        found_default = default_paths.select { |p| File.exist?(p) }
-        if found_default.size > 1
-          @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
-      # rubocop:disable YAMLLoad
-      File.open(path, "r:UTF-8") { |f| YAML.load(f.read) }
-    rescue Errno::ENOENT
-      if path_passed
-        raise Bolt::CLIError, "Could not read config file: #{path}"
-      end
-    # In older releases of psych SyntaxError is not a subclass of Exception
-    rescue Psych::SyntaxError
-      raise Bolt::CLIError, "Could not parse config file: #{path}"
-    rescue Psych::Exception
-      raise Bolt::CLIError, "Could not parse config file: #{path}"
-    rescue IOError, SystemCallError
-      raise Bolt::CLIError, "Could not read config file: #{path}"
-    end
-
     def update_from_file(data)
       if data['modulepath']
         self[:modulepath] = data['modulepath'].split(File::PATH_SEPARATOR)
       end
 
+      if data['inventoryfile']
+        self[:inventoryfile] = data['inventoryfile']
+      end
+
       if data['concurrency']
         self[:concurrency] = data['concurrency']
       end
@@ -166,12 +142,12 @@ module Bolt
     end
 
     def load_file(path)
-      data = read_config_file(path)
+      data = Bolt::Util.read_config_file(path, default_paths, 'config')
       update_from_file(data) if data
     end
 
     def update_from_cli(options)
-      %i[concurrency transport format modulepath].each do |key|
+      %i[concurrency transport format modulepath inventoryfile].each do |key|
         self[key] = options[key] if options[key]
       end
 
@@ -200,6 +176,11 @@ module Bolt
       end
     end
 
+    def transport_conf
+      { transport: self[:transport],
+        transports: self[:transports] }
+    end
+
     def validate
       TRANSPORTS.each do |transport|
         self[:transports][transport]

data/lib/bolt/error.rb

@@ -25,20 +25,31 @@ module Bolt
     def to_json(opts = nil)
       to_h.to_json(opts)
     end
+
+    def to_puppet_error
+      Puppet::DataTypes::Error.from_asserted_hash(to_h)
+    end
   end
 
   class RunFailure < Error
-    attr_reader :resultset
+    attr_reader :result_set
 
-    def initialize(resultset, action, object)
+    def initialize(result_set, action, object)
       details = {
-        action: action,
-        object: object,
-        failed_targets: resultset.error_set.names
+        'action' => action,
+        'object' =>  object,
+        'result_set' => result_set
       }
-      message = "Plan aborted: #{action} '#{object}' failed on #{details[:failed_targets].length} nodes"
+      message = "Plan aborted: #{action} '#{object}' failed on #{result_set.error_set.length} nodes"
       super(message, 'bolt/run-failure', details)
-      @resultset = resultset
+      @result_set = result_set
+      @error_code = 2
+    end
+  end
+
+  class PlanFailure < Error
+    def initialize(*args)
+      super(*args)
       @error_code = 2
     end
   end

data/lib/bolt/executor.rb

@@ -28,7 +28,7 @@ module Bolt
 
     def from_targets(targets)
       targets.map do |target|
-        Bolt::Node.from_target(target, config: @config)
+        Bolt::Node.from_target(target)
       end
     end
     private :from_targets
@@ -150,7 +150,7 @@ module Bolt
       r
     end
 
-    def file_upload(targets, source, destination)
+    def file_upload(targets, source, destination, options = {})
       nodes = from_targets(targets)
       @logger.info("Starting file upload from #{source} to #{destination} on #{nodes.map(&:uri)}")
       callback = block_given? ? Proc.new : nil
@@ -158,7 +158,7 @@ module Bolt
       r = on(nodes, callback) do |node|
         @logger.debug { "Uploading: '#{source}' to #{destination} on #{node.uri}" }
         node_result = with_exception_handling(node) do
-          node.upload(source, destination)
+          node.upload(source, destination, options)
         end
         @logger.debug("Result on #{node.uri}: #{JSON.dump(node_result.value)}")
         node_result

data/lib/bolt/inventory.rb

@@ -0,0 +1,101 @@
+require 'set'
+require 'bolt/util'
+require 'bolt/target'
+require 'bolt/inventory/group'
+
+module Bolt
+  class Inventory
+    class ValidationError < Bolt::Error
+      attr_accessor :path
+      def initialize(message, offending_group)
+        super(msg, 'bolt.inventory/validation-error')
+        @_message = message
+        @path = offending_group ? [offending_group] : []
+      end
+
+      def details
+        { 'path' => path }
+      end
+
+      def add_parent(parent_group)
+        @path << parent_group
+      end
+
+      def message
+        "#{@_message} for group at #{path}"
+      end
+    end
+
+    def self.default_paths
+      [File.expand_path(File.join('~', '.puppetlabs', 'bolt', 'inventory.yaml'))]
+    end
+
+    def self.from_config(config)
+      data = Bolt::Util.read_config_file(config[:inventoryfile], default_paths, 'inventory')
+
+      inventory = new(data, config)
+      inventory.validate
+      inventory
+    end
+
+    def initialize(data, config = nil)
+      @logger = Logging.logger[self]
+      # Config is saved to add config options to targets
+      @config = config || {}
+      @data = data ||= {}
+      @groups = Group.new(data.merge('name' => 'all'))
+    end
+
+    def validate
+      @groups.validate
+    end
+
+    def get_targets(targets)
+      targets = expand_targets(targets)
+      targets = if targets.is_a? Array
+                  targets.flatten.uniq(&:name)
+                else
+                  [targets]
+                end
+      targets.map { |t| update_target(t) }
+    end
+
+    # Should this be a public method?
+    def config_for(node_name)
+      data = @groups.data_for(node_name)
+      if data
+        Bolt::Util.symbolize_keys(data['config'])
+      end
+    end
+
+    #### PRIVATE ####
+    #
+    # For debugging only now
+    def groups_in(node_name)
+      @groups.data_for(node_name)['groups'] || {}
+    end
+
+    # Pass a target to get_targets for a public version of this
+    # Should this reconfigure configured targets?
+    def update_target(target)
+      inv_conf = config_for(target.host)
+      unless inv_conf
+        @logger.debug("Did not find #{target.host} in inventory")
+        inv_conf = {}
+      end
+
+      conf = Bolt::Util.deep_merge(@config.transport_conf, inv_conf)
+      target.update_conf(conf)
+    end
+
+    def expand_targets(targets)
+      if targets.is_a? Bolt::Target
+        targets
+      elsif targets.is_a? Array
+        targets.map { |tish| expand_targets(tish) }
+      elsif targets.is_a? String
+        Bolt::Target.new(targets)
+      end
+    end
+  end
+end

data/lib/bolt/inventory/group.rb

@@ -0,0 +1,127 @@
+module Bolt
+  class Inventory
+    # Group is a specific implementation of Inventory based on nested
+    # structred data.
+    class Group
+      attr_accessor :name, :nodes, :groups, :config, :rest
+
+      def initialize(data)
+        @name = data['name']
+
+        @nodes = if data['nodes']
+                   data['nodes'].map do |n|
+                     if n.is_a? String
+                       { 'name' => n }
+                     else
+                       n
+                     end
+                   end
+                 else
+                   []
+                 end
+        @config = data['config'] || {}
+        @groups = if data['groups']
+                    data['groups'].map { |g| Group.new(g) }
+                  else
+                    []
+                  end
+
+        # this allows arbitrary info for the top level
+        @rest = data.reject { |k, _| %w[name nodes config groups].include? k }
+      end
+
+      def validate(used_names = [], depth = 0)
+        raise ValidationError.new("Group does not have a name", nil)  unless @name
+        if used_names.include?(@name)
+          raise ValidationError.new("Tried to redefine group #{@name}", @name)
+        end
+        raise ValidationError.new("Invalid Group name #{@name}", @name) unless @name =~ /\A[a-z0-9_]+\Z/
+
+        raise ValidationError.new("Group #{@name} is too deeply nested", @name) if depth > 1
+
+        used_names << @name
+
+        @nodes.each do |n|
+          raise ValidationError.new("node #{n['name']} does not have a name", @name) unless n['name']
+        end
+
+        @groups.each do |g|
+          begin
+            g.validate(used_names, depth + 1)
+          rescue ValidationError => e
+            e.add_parent(@name)
+            raise e
+          end
+        end
+        nil
+      end
+
+      # The data functions below expect and return nil or a hash of the schema
+      # { 'config' => Hash , groups => Array }
+      # As we add more options beyond config this schema will grow
+      def data_for(node_name)
+        data_merge(group_collect(node_name), node_collect(node_name))
+      end
+
+      def node_data(node_name)
+        if (data = @nodes.find { |n| n['name'] == node_name })
+          { 'config' => data['config'] || {},
+            # groups come from group_data
+            'groups' => [] }
+        end
+      end
+
+      def group_data
+        { 'config' => @config,
+          'groups' => [@name] }
+      end
+
+      def empty_data
+        { 'config' => {},
+          'groups' => [] }
+      end
+
+      def data_merge(data1, data2)
+        if data2.nil? || data1.nil?
+          return data2 || data1
+        end
+
+        {
+          'config' => Bolt::Util.deep_merge(data1['config'], data2['config']),
+          'groups' => data2['groups'] + data1['groups']
+        }
+      end
+
+      def node_names
+        @_node_names ||= Set.new(nodes.map { |n| n['name'] })
+      end
+
+      def node_collect(node_name)
+        data = @groups.inject(nil) do |acc, g|
+          if (d = g.node_collect(node_name))
+            data_merge(d, acc)
+          else
+            acc
+          end
+        end
+        data_merge(node_data(node_name), data)
+      end
+
+      def group_collect(node_name)
+        data = @groups.inject(nil) do |acc, g|
+          if (d = g.data_for(node_name))
+            data_merge(d, acc)
+          else
+            acc
+          end
+        end
+
+        if data
+          data_merge(group_data, data)
+        elsif node_names.include?(node_name)
+          group_data
+        end
+      end
+    end
+  end
+end