bolt 0.16.4 → 0.17.0

data/lib/bolt/config.rb

@@ -3,11 +3,14 @@ require 'bolt/cli'
 require 'logging'
 
 module Bolt
+  TRANSPORTS = %i[ssh winrm pcp local].freeze
+
   Config = Struct.new(
     :concurrency,
     :format,
     :inventoryfile,
     :log_level,
+    :log,
     :modulepath,
     :transport,
     :transports
@@ -16,16 +19,16 @@ module Bolt
     DEFAULTS = {
       concurrency: 100,
       transport: 'ssh',
-      format: 'human'
+      format: 'human',
+      modulepath: []
     }.freeze
 
     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
+                           token-file task-environment service-url].freeze
 
     TRANSPORT_DEFAULTS = {
       connect_timeout: 10,
-      orch_task_environment: 'production',
       tty: false
     }.freeze
 
@@ -36,16 +39,21 @@ module Bolt
       winrm: {
         ssl: true
       },
-      pcp: {}
+      pcp: {
+        :"task-environment" => 'production'
+      },
+      local: {}
     }.freeze
 
-    TRANSPORTS = %i[ssh winrm pcp].freeze
-
     def initialize(**kwargs)
       super()
       @logger = Logging.logger[self]
       DEFAULTS.merge(kwargs).each { |k, v| self[k] = v }
 
+      # add an entry for the default console logger
+      self[:log] ||= {}
+      self[:log]['console'] ||= {}
+
       self[:transports] ||= {}
       TRANSPORTS.each do |transport|
         unless self[:transports][transport]
@@ -65,12 +73,38 @@ module Bolt
       end
     end
 
+    def deep_clone
+      Bolt::Util.deep_clone(self)
+    end
+
     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 normalize_log(target)
+      return target if target == 'console'
+      target = target[5..-1] if target.start_with?('file:')
+      'file:' << File.expand_path(target)
+    end
+
     def update_from_file(data)
+      if data['log'].is_a?(Hash)
+        data['log'].each_pair do |k, v|
+          log = (self[:log][normalize_log(k)] ||= {})
+
+          next unless v.is_a?(Hash)
+
+          if v.key?('level')
+            log[:level] = v['level'].to_s
+          end
+
+          if v.key?('append')
+            log[:append] = v['append']
+          end
+        end
+      end
+
       if data['modulepath']
         self[:modulepath] = data['modulepath'].split(File::PATH_SEPARATOR)
       end
@@ -84,7 +118,7 @@ module Bolt
       end
 
       if data['format']
-        self[:format] = data['format'] if data['format']
+        self[:format] = data['format']
       end
 
       if data['ssh']
@@ -127,19 +161,26 @@ module Bolt
 
       if data['pcp']
         if data['pcp']['service-url']
-          self[:transports][:pcp][:service_url] = 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']
+          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']
+          self[:transports][:pcp][:"task-environment"] = data['pcp']['task-environment']
+        end
+      end
+
+      if data['local']
+        if data['local']['tmpdir']
+          self[:transports][:local][:tmpdir] = data['local']['tmpdir']
         end
       end
     end
+    private :update_from_file
 
     def load_file(path)
       data = Bolt::Util.read_config_file(path, default_paths, 'config')
@@ -152,14 +193,14 @@ module Bolt
       end
 
       if options[:debug]
-        self[:log_level] = :debug
+        self[:log]['console'][:level] = :debug
       elsif options[:verbose]
-        self[:log_level] = :info
+        self[:log]['console'][:level] = :info
       end
 
       TRANSPORT_OPTIONS.each do |key|
         TRANSPORTS.each do |transport|
-          unless %i[ssl host_key_check].any? { |k| k == key }
+          unless %i[ssl host_key_check task-environment].any? { |k| k == key }
             self[:transports][transport][key] = options[key] if options[key]
             next
           end
@@ -176,6 +217,27 @@ module Bolt
       end
     end
 
+    def update_from_inventory(data)
+      update_from_file(data)
+
+      if data['transport']
+        self[:transport] = data['transport']
+      end
+
+      # Add options that aren't allowed in a config file, but are allowed in inventory
+      %w[user password port].each do |opt|
+        (TRANSPORTS - [:pcp]).each do |transport|
+          if data[transport.to_s] && data[transport.to_s][opt]
+            self[:transports][transport][opt.to_sym] = data[transport.to_s][opt]
+          end
+        end
+      end
+
+      if data['ssh'] && data['ssh']['sudo-password']
+        self[:transports][:ssh][:sudo_password] = data['ssh']['sudo-password']
+      end
+    end
+
     def transport_conf
       { transport: self[:transport],
         transports: self[:transports] }
@@ -186,6 +248,16 @@ module Bolt
         self[:transports][transport]
       end
 
+      self[:log].each_pair do |name, params|
+        if params.key?(:level) && !Bolt::Logger.valid_level?(params[:level])
+          raise Bolt::CLIError,
+                "level of log #{name} must be one of: #{Bolt::Logger.levels.join(', ')}; received #{params[:level]}"
+        end
+        if params.key?(:append) && params[:append] != true && params[:append] != false
+          raise Bolt::CLIError, "append flag of log #{name} must be a Boolean, received #{params[:append]}"
+        end
+      end
+
       unless %w[human json].include? self[:format]
         raise Bolt::CLIError, "Unsupported format: '#{self[:format]}'"
       end
@@ -195,6 +267,16 @@ module Bolt
                      "user to escalate to with --run-as")
       end
 
+      host_key = self[:transports][:ssh][:host_key_check]
+      unless !!host_key == host_key
+        raise Bolt::CLIError, 'host-key-check option must be a Boolean true or false'
+      end
+
+      ssl_flag = self[:transports][:winrm][:ssl]
+      unless !!ssl_flag == ssl_flag
+        raise Bolt::CLIError, 'ssl option must be a Boolean true or false'
+      end
+
       self[:transports].each_value do |v|
         timeout_value = v[:connect_timeout]
         unless timeout_value.is_a?(Integer) || timeout_value.nil?

data/lib/bolt/executor.rb

@@ -10,6 +10,7 @@ require 'bolt/result_set'
 require 'bolt/transport/ssh'
 require 'bolt/transport/winrm'
 require 'bolt/transport/orch'
+require 'bolt/transport/local'
 
 module Bolt
   class Executor
@@ -23,7 +24,8 @@ module Bolt
       @transports = {
         'ssh' => Concurrent::Delay.new { Bolt::Transport::SSH.new(config[:transports][:ssh] || {}) },
         'winrm' => Concurrent::Delay.new { Bolt::Transport::WinRM.new(config[:transports][:winrm] || {}) },
-        'pcp' => Concurrent::Delay.new { Bolt::Transport::Orch.new(config[:transports][:pcp] || {}) }
+        'pcp' => Concurrent::Delay.new { Bolt::Transport::Orch.new(config[:transports][:pcp] || {}) },
+        'local' => Concurrent::Delay.new { Bolt::Transport::Local.new(config[:transports][:local] || {}) }
       }
 
       # If a specific elevated log level has been requested, honor that.
@@ -39,7 +41,10 @@ module Bolt
     end
 
     def transport(transport)
-      @transports[transport || 'ssh'].value
+      impl = @transports[transport || 'ssh']
+      # If there was an error creating the transport, ensure it gets thrown
+      impl.no_error!
+      impl.value
     end
 
     def summary(action, object, result)
@@ -58,10 +63,12 @@ module Bolt
     # transport, is yielded to the block in turn and the results all collected
     # into a single ResultSet.
     def batch_execute(targets)
-      promises = targets.group_by(&:protocol).flat_map do |protocol, _protocol_targets|
+      promises = targets.group_by(&:protocol).flat_map do |protocol, protocol_targets|
         transport = transport(protocol)
-        transport.batches(targets).flat_map do |batch|
-          batch_promises = Hash[Array(batch).map { |target| [target, Concurrent::Promise.new(executor: :immediate)] }]
+        transport.batches(protocol_targets).flat_map do |batch|
+          batch_promises = Array(batch).each_with_object({}) do |target, h|
+            h[target] = Concurrent::Promise.new(executor: :immediate)
+          end
           # Pass this argument through to avoid retaining a reference to a
           # local variable that will change on the next iteration of the loop.
           @pool.post(batch_promises) do |result_promises|

data/lib/bolt/inventory.rb

@@ -42,6 +42,7 @@ module Bolt
       inventory = new(data, config)
       inventory.validate
       inventory.collect_groups
+      inventory.add_localhost
       inventory
     end
 
@@ -52,6 +53,7 @@ module Bolt
       @data = data ||= {}
       @groups = Group.new(data.merge('name' => 'all'))
       @group_lookup = {}
+      @target_vars = {}
     end
 
     def validate
@@ -63,6 +65,16 @@ module Bolt
       @group_lookup = @groups.collect_groups
     end
 
+    def add_localhost
+      # Append a 'localhost' group if not already present.
+      unless @group_lookup.include?('localhost') || @groups.node_names.include?('localhost')
+        @groups.nodes['localhost'] = {
+          'name' => 'localhost',
+          'config' => { 'transport' => 'local' }
+        }
+      end
+    end
+
     def get_targets(targets)
       targets = expand_targets(targets)
       targets = if targets.is_a? Array
@@ -73,12 +85,13 @@ module Bolt
       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
+    def set_var(target, key, value)
+      data = { key => value }
+      set_vars_from_hash(target.name, data)
+    end
+
+    def vars(target)
+      @target_vars[target.name]
     end
 
     #### PRIVATE ####
@@ -87,18 +100,31 @@ module Bolt
     def groups_in(node_name)
       @groups.data_for(node_name)['groups'] || {}
     end
+    private :groups_in
 
     # 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.name)
-      unless inv_conf
+      data = @groups.data_for(target.name) || {}
+
+      unless data['config']
         @logger.debug("Did not find #{target.name} in inventory")
-        inv_conf = {}
+        data['config'] = {}
       end
 
-      conf = Bolt::Util.deep_merge(@config.transport_conf, inv_conf)
-      target.update_conf(conf)
+      unless data['vars']
+        @logger.debug("Did not find any variables for #{target.name} in inventory")
+        data['vars'] = {}
+      end
+
+      set_vars_from_hash(target.name, data['vars'])
+
+      # Use Config object to ensure config section is treated consistently with config file
+      conf = @config.deep_clone
+      conf.update_from_inventory(data['config'])
+      conf.validate
+
+      target.update_conf(conf.transport_conf)
     end
     private :update_target
 
@@ -142,5 +168,16 @@ module Bolt
       end
     end
     private :expand_targets
+
+    def set_vars_from_hash(target_name, data)
+      if data
+        # Instantiate empty vars hash in case no vars are defined
+        @target_vars[target_name] = @target_vars[target_name] || {}
+        # Assign target new merged vars hash
+        # This is essentially a copy-on-write to maintain the immutability of @target_vars
+        @target_vars[target_name] = @target_vars[target_name].merge(data).freeze
+      end
+    end
+    private :set_vars_from_hash
   end
 end

data/lib/bolt/inventory/group.rb

@@ -8,8 +8,8 @@ module Bolt
       def initialize(data)
         @logger = Logging.logger[self]
         @name = data['name']
-
         @nodes = {}
+
         if data['nodes']
           data['nodes'].each do |n|
             n = { 'name' => n } if n.is_a? String
@@ -21,6 +21,7 @@ module Bolt
           end
         end
 
+        @vars = data['vars'] || {}
         @config = data['config'] || {}
         @groups = if data['groups']
                     data['groups'].map { |g| Group.new(g) }
@@ -32,6 +33,14 @@ module Bolt
         @rest = data.reject { |k, _| %w[name nodes config groups].include? k }
       end
 
+      def check_deprecated_config(context, name, config)
+        if config && config['transports']
+          msg = "#{context} #{name} contains invalid config option 'transports', see " \
+                "https://puppet.com/docs/bolt/0.x/inventory_file.html for the updated format"
+          raise ValidationError.new(msg, @name)
+        end
+      end
+
       def validate(used_names = Set.new, node_names = Set.new, depth = 0)
         raise ValidationError.new("Group does not have a name", nil) unless @name
         if used_names.include?(@name)
@@ -44,6 +53,8 @@ module Bolt
         end
         raise ValidationError.new("Group #{@name} is too deeply nested", @name) if depth > 1
 
+        check_deprecated_config('Group', @name, @config)
+
         used_names << @name
 
         @nodes.each_value do |n|
@@ -60,6 +71,8 @@ module Bolt
             raise ValidationError.new("Group #{n['name']} conflicts with node of the same name", n['name'])
           end
 
+          check_deprecated_config('Node', n['name'], n['config'])
+
           node_names << n['name']
         end
 
@@ -76,7 +89,7 @@ module Bolt
       end
 
       # The data functions below expect and return nil or a hash of the schema
-      # { 'config' => Hash , groups => Array }
+      # { 'config' => Hash , 'vars' => 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))
@@ -85,6 +98,7 @@ module Bolt
       def node_data(node_name)
         if (data = @nodes[node_name])
           { 'config' => data['config'] || {},
+            'vars' => data['vars'] || {},
             # groups come from group_data
             'groups' => [] }
         end
@@ -92,11 +106,13 @@ module Bolt
 
       def group_data
         { 'config' => @config,
+          'vars'   => @vars,
           'groups' => [@name] }
       end
 
       def empty_data
         { 'config' => {},
+          'vars'   => {},
           'groups' => [] }
       end
 
@@ -107,6 +123,10 @@ module Bolt
 
         {
           'config' => Bolt::Util.deep_merge(data1['config'], data2['config']),
+          # Shallow merge instead of deep merge so that vars with a hash value
+          # are assigned a new hash, rather than merging the existing value
+          # with the value meant to replace it
+          'vars'   => data2['vars'].merge(data1['vars']),
           'groups' => data2['groups'] + data1['groups']
         }
       end