bolt 0.16.4 → 0.17.0

data/lib/bolt/logger.rb

@@ -13,16 +13,64 @@ module Bolt
       return if Logging.initialized?
 
       Logging.init :debug, :info, :notice, :warn, :error, :fatal, :any
-      Logging.appenders.stderr(
-        'stderr',
-        layout: Logging.layouts.pattern(
-          pattern: '%d %-6l %c: %m\n',
-          date_pattern: '%Y-%m-%dT%H:%M:%S.%6N'
-        )
+
+      root_logger = Logging.logger[:root]
+      root_logger.add_appenders Logging.appenders.stderr(
+        'console',
+        layout: default_layout,
+        level: default_level
       )
+      # We set the root logger's level so that it logs everything but we do
+      # limit what's actually logged in every appender individually.
+      root_logger.level = :all
+    end
+
+    def self.configure(config)
       root_logger = Logging.logger[:root]
-      root_logger.add_appenders :stderr
-      root_logger.level = :notice
+
+      config[:log].each_pair do |name, params|
+        appender = Logging.appenders[name]
+        if appender.nil?
+          unless name.start_with?('file:')
+            raise Bolt::Error.new("Unexpected log: #{name}", 'bolt/internal-error')
+          end
+
+          begin
+            appender = Logging.appenders.file(
+              name,
+              filename: name[5..-1], # strip the "file:" prefix
+              truncate: (params[:append] == false),
+              layout: default_layout,
+              level: default_level
+            )
+          rescue ArgumentError => e
+            raise Bolt::CLIError, "Failed to open log #{name}: #{e.message}"
+          end
+
+          root_logger.add_appenders appender
+        end
+
+        appender.level = params[:level] if params[:level]
+      end
+    end
+
+    def self.default_layout
+      @default_layout ||= Logging.layouts.pattern(
+        pattern: '%d %-6l %c: %m\n',
+        date_pattern: '%Y-%m-%dT%H:%M:%S.%6N'
+      )
+    end
+
+    def self.default_level
+      :notice
+    end
+
+    def self.valid_level?(level)
+      !Logging.level_num(level).nil?
+    end
+
+    def self.levels
+      Logging::LNAMES.map(&:downcase)
     end
 
     def self.reset_logging

data/lib/bolt/outputter/human.rb

@@ -72,7 +72,24 @@ module Bolt
       end
 
       def print_summary(results, elapsed_time)
-        @stream.puts format("Ran on %d node%s in %.2f seconds",
+        ok_set = results.ok_set
+        unless ok_set.empty?
+          @stream.puts format('Successful on %d node%s: %s',
+                              ok_set.size,
+                              ok_set.size == 1 ? '' : 's',
+                              ok_set.names.join(','))
+        end
+
+        error_set = results.error_set
+        unless error_set.empty?
+          @stream.puts colorize(:red,
+                                format('Failed on %d node%s: %s',
+                                       error_set.size,
+                                       error_set.size == 1 ? '' : 's',
+                                       error_set.names.join(',')))
+        end
+
+        @stream.puts format('Ran on %d node%s in %.2f seconds',
                             results.size,
                             results.size == 1 ? '' : 's',
                             elapsed_time)

data/lib/bolt/pal.rb

@@ -4,6 +4,7 @@ require 'bolt/error'
 module Bolt
   class PAL
     BOLTLIB_PATH = File.join(__FILE__, '../../../bolt-modules')
+    MODULES_PATH = File.join(__FILE__, '../../../modules')
 
     def initialize(config)
       # Nothing works without initialized this global state. Reinitializing
@@ -55,12 +56,16 @@ module Bolt
       compiler.evaluate_string('type TargetSpec = Boltlib::TargetSpec')
     end
 
+    def full_modulepath(modulepath)
+      [BOLTLIB_PATH, *modulepath, MODULES_PATH]
+    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|
+      r = Puppet::Pal.in_tmp_environment('bolt', modulepath: full_modulepath(@config[:modulepath]), facts: {}) do |pal|
         pal.with_script_compiler do |compiler|
           add_target_spec(compiler)
           begin

data/lib/bolt/target.rb

@@ -58,7 +58,7 @@ module Bolt
       @uri_obj.hostname
     end
 
-    # name is currently just uri but should be be used instead to identify the
+    # name is currently just uri but should be used instead to identify the
     # Target ouside the transport or uri options.
     def name
       uri

data/lib/bolt/transport/base.rb

@@ -34,6 +34,9 @@ module Bolt
     # before executing, and a :node_result event for each Target after
     # execution.
     class Base
+      STDIN_METHODS       = %w[both stdin].freeze
+      ENVIRONMENT_METHODS = %w[both environment].freeze
+
       attr_reader :logger
 
       def initialize(_config)

data/lib/bolt/transport/local.rb

@@ -0,0 +1,90 @@
+require 'json'
+require 'fileutils'
+require 'tmpdir'
+require 'bolt/transport/base'
+require 'bolt/result'
+
+module Bolt
+  module Transport
+    class Local < Base
+      def initialize(config = nil)
+        super(config)
+
+        if Gem.win_platform?
+          raise NotImplementedError, "The local transport is not yet implemented on Windows"
+        else
+          @conn = Shell.new
+        end
+      end
+
+      def in_tmpdir(base)
+        args = base ? [nil, base] : []
+        Dir.mktmpdir(*args) do |dir|
+          Dir.chdir(dir) do
+            yield dir
+          end
+        end
+      rescue StandardError => e
+        raise Bolt::Node::FileError.new("Could not make tempdir: #{e.message}", 'TEMPDIR_ERROR')
+      end
+      private :in_tmpdir
+
+      def copy_file(source, destination)
+        FileUtils.copy_file(source, destination)
+      rescue StandardError => e
+        raise Bolt::Node::FileError.new(e.message, 'WRITE_ERROR')
+      end
+
+      def with_tmpscript(script, base)
+        in_tmpdir(base) do |dir|
+          dest = File.join(dir, File.basename(script))
+          copy_file(script, dest)
+          File.chmod(0o750, dest)
+          yield dest
+        end
+      end
+      private :with_tmpscript
+
+      def upload(target, source, destination, _options = {})
+        copy_file(source, destination)
+        Bolt::Result.for_upload(target, source, destination)
+      end
+
+      def run_command(target, command, _options = {})
+        in_tmpdir(target.options[:tmpdir]) do |_|
+          output = @conn.execute(command, {})
+          Bolt::Result.for_command(target, output.stdout.string, output.stderr.string, output.exit_code)
+        end
+      end
+
+      def run_script(target, script, arguments, _options = {})
+        with_tmpscript(File.absolute_path(script), target.options[:tmpdir]) do |file|
+          logger.debug "Running '#{file}' with #{arguments}"
+
+          if arguments.empty?
+            # We will always provide separated arguments, so work-around Open3's handling of a single
+            # argument as the entire command string for script paths containing spaces.
+            arguments = ['']
+          end
+          output = @conn.execute(file, *arguments, {})
+          Bolt::Result.for_command(target, output.stdout.string, output.stderr.string, output.exit_code)
+        end
+      end
+
+      def run_task(target, task, arguments, _options = {})
+        input_method = task.input_method
+        stdin = STDIN_METHODS.include?(input_method) ? JSON.dump(arguments) : nil
+        env = ENVIRONMENT_METHODS.include?(input_method) ? arguments : nil
+
+        with_tmpscript(task.executable, target.options[:tmpdir]) do |script|
+          logger.debug("Running '#{script}' with #{arguments}")
+
+          output = @conn.execute(script, stdin: stdin, env: env)
+          Bolt::Result.for_task(target, output.stdout.string, output.stderr.string, output.exit_code)
+        end
+      end
+    end
+  end
+end
+
+require 'bolt/transport/local/shell'

data/lib/bolt/transport/local/shell.rb

@@ -0,0 +1,29 @@
+require 'open3'
+require 'bolt/node/output'
+
+module Bolt
+  module Transport
+    class Local
+      class Shell
+        def execute(*command, options)
+          if options[:env]
+            env = options[:env].each_with_object({}) { |(k, v), h| h["PT_#{k}"] = v }
+            command = [env] + command
+          end
+
+          if options[:stdin]
+            stdout, stderr, rc = Open3.capture3(*command, stdin_data: options[:stdin])
+          else
+            stdout, stderr, rc = Open3.capture3(*command)
+          end
+
+          result_output = Bolt::Node::Output.new
+          result_output.stdout << stdout unless stdout.nil?
+          result_output.stderr << stderr unless stderr.nil?
+          result_output.exit_code = rc.to_i
+          result_output
+        end
+      end
+    end
+  end
+end

data/lib/bolt/transport/orch.rb

@@ -27,7 +27,7 @@ module Bolt
 
       def build_request(targets, task, arguments)
         { task: task.name,
-          environment: targets.first.options[:orch_task_environment],
+          environment: targets.first.options[:"task-environment"],
           noop: arguments['_noop'],
           params: arguments.reject { |k, _| k == '_noop' },
           scope: {
@@ -117,7 +117,7 @@ module Bolt
 
       def batches(targets)
         targets.group_by do |target|
-          [target.options[:orch_task_environment],
+          [target.options[:"task-environment"],
            target.options[:"service-url"],
            target.options[:"token-file"]]
         end.values

data/lib/bolt/transport/ssh.rb

@@ -6,9 +6,6 @@ require 'shellwords'
 module Bolt
   module Transport
     class SSH < Base
-      STDIN_METHODS       = %w[both stdin].freeze
-      ENVIRONMENT_METHODS = %w[both environment].freeze
-
       def initialize(_config)
         super
 

data/lib/bolt/transport/winrm.rb

@@ -3,9 +3,6 @@ require 'bolt/transport/base'
 module Bolt
   module Transport
     class WinRM < Base
-      STDIN_METHODS       = %w[both stdin].freeze
-      ENVIRONMENT_METHODS = %w[both environment].freeze
-
       PS_ARGS = %w[
         -NoProfile -NonInteractive -NoLogo -ExecutionPolicy Bypass
       ].freeze

data/lib/bolt/util.rb

@@ -43,10 +43,37 @@ module Bolt
         hash1.merge(hash2, &recursive_merge)
       end
 
-      def symbolize_keys(hash)
-        hash.each_with_object({}) do |(k, v), acc|
-          k = k.to_sym
-          acc[k] = v.is_a?(Hash) ? symbolize_keys(v) : v
+      # Performs a deep_clone, using an identical copy if the cloned structure contains multiple
+      # references to the same object and prevents endless recursion.
+      # Credit to Jan Molic via https://github.com/rubyworks/facets/blob/master/LICENSE.txt
+      def deep_clone(obj, cloned = {})
+        cloned[obj.object_id] if cloned.include?(obj.object_id)
+
+        begin
+          cl = obj.clone
+        rescue TypeError
+          # unclonable (TrueClass, Fixnum, ...)
+          cloned[obj.object_id] = obj
+          return obj
+        else
+          cloned[obj.object_id] = cl
+          cloned[cl.object_id] = cl
+
+          if cl.is_a? Hash
+            obj.each { |k, v| cl[k] = deep_clone(v, cloned) }
+          elsif cl.is_a? Array
+            cl.collect! { |v| deep_clone(v, cloned) }
+          elsif cl.is_a? Struct
+            obj.each_pair { |k, v| cl[k] = deep_clone(v, cloned) }
+          end
+
+          cl.instance_variables.each do |var|
+            v = cl.instance_eval { var }
+            v_cl = deep_clone(v, cloned)
+            cl.instance_eval { @var = v_cl }
+          end
+
+          return cl
         end
       end
     end

data/lib/bolt/version.rb

@@ -1,3 +1,3 @@
 module Bolt
-  VERSION = '0.16.4'.freeze
+  VERSION = '0.17.0'.freeze
 end

data/lib/bolt_ext/puppetdb_inventory.rb

@@ -9,7 +9,12 @@ module Bolt
   class PuppetDBInventory
     class Client
       def self.from_config(config)
-        uri = URI.parse(config['server_urls'].first)
+        uri = if config['server_urls'].is_a? String
+                config['server_urls']
+              else
+                config['server_urls'].first
+              end
+        uri = URI.parse(uri)
         uri.port ||= 8081
 
         cacert = File.expand_path(config['cacert'])
@@ -83,6 +88,8 @@ module Bolt
           end
         elsif File.exist?(DEFAULT_CONFIG)
           config = JSON.parse(File.read(DEFAULT_CONFIG))
+        else
+          config = {}
         end
         config.fetch('puppetdb', {})
       end
@@ -197,7 +204,7 @@ query results.
 
         inventory_file = positional_args.shift
         unless inventory_file
-          raise "--inventory is a required option"
+          raise "Please specify an input file (see --help for details)"
         end
 
         if positional_args.any?

data/modules/aggregate/lib/puppet/functions/aggregate/count.rb

@@ -0,0 +1,19 @@
+# Aggregates the key/value pairs in the results of a ResultSet into a hash
+# mapping the keys to a hash of each distinct value and how many nodes returned
+# that value for the key.
+Puppet::Functions.create_function(:'aggregate::count') do
+  dispatch :aggregate_count do
+    param 'ResultSet', :resultset
+  end
+
+  def aggregate_count(resultset)
+    resultset.each_with_object({}) do |result, agg|
+      result.value.each do |key, val|
+        agg[key] ||= {}
+        agg[key][val.to_s] ||= 0
+        agg[key][val.to_s] += 1
+      end
+      agg
+    end
+  end
+end

data/modules/aggregate/lib/puppet/functions/aggregate/nodes.rb

@@ -0,0 +1,19 @@
+# Aggregates the key/value pairs in the results of a ResultSet into a hash
+# mapping the keys to a hash of each distinct value and the list of nodes
+# returning that value for the key.
+Puppet::Functions.create_function(:'aggregate::nodes') do
+  dispatch :aggregate_nodes do
+    param 'ResultSet', :resultset
+  end
+
+  def aggregate_nodes(resultset)
+    resultset.each_with_object({}) do |result, agg|
+      result.value.each do |key, val|
+        agg[key] ||= {}
+        agg[key][val.to_s] ||= []
+        agg[key][val.to_s] << result.target.name
+      end
+      agg
+    end
+  end
+end

data/modules/aggregate/plans/count.pp

@@ -0,0 +1,35 @@
+plan aggregate::count(
+  Optional[String[0]] $task = undef,
+  Optional[String[0]] $command = undef,
+  Optional[String[0]] $script = undef,
+  TargetSpec $nodes,
+  Hash[String, Data] $params = {}
+) {
+
+  # Validation
+  $type_count = [$task, $command, $script].reduce(0) |$acc, $v| {
+    if ($v) {
+      $acc + 1
+    } else {
+      $acc
+    }
+  }
+
+  if ($type_count == 0) {
+    fail_plan("Must specify a command, script, or task to run", 'canary/invalid-params')
+  }
+
+  if ($type_count > 1) {
+    fail_plan("Must specify only one command, script, or task to run", 'canary/invalid-params')
+  }
+
+  $res = if ($task) {
+    run_task($task, $nodes, $params)
+  } elsif ($command) {
+    run_command($command, $nodes, $params)
+  } elsif ($script) {
+    run_script($script, $nodes, $params)
+  }
+
+  aggregate::count($res)
+}