bolt 0.20.0 → 0.20.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c025d775da13c9ea704f4b701097246e77122f96
-  data.tar.gz: 49dfd9c9bc82fd52e1f466478075a5a097a5d2d7
+  metadata.gz: 39bf1a34b5705fc648c41ca2f722631fc9f0c556
+  data.tar.gz: f401ef340be9a8acb42b9e54547b2560679784da
 SHA512:
-  metadata.gz: 729d196fadd790ca39f2221d4102cf7289dba33928b90b31cee222d18a46fc3670d9975dcd704428b2fec9b75118f69abf99a2d4399dbc726e3319098169d27d
-  data.tar.gz: 507b895715fbc982a5267bc37b023f1ad6bc42364b382eaec246cd7c2cae0c4720df3ec59a94075511fa5788f0f0e7341ad2486b1dbe12e2bd20e9ce07be3e71
+  metadata.gz: 9206ab261f57b68900ed68d3f6d492fde9935b4c232546fbc762a6a6bc80bc1e9b5c011a1d98312c8f4336525dd549f232c50c3d3e823a0709c6a5855976cfca
+  data.tar.gz: f9b91fa75d5ffe98d10bf21aeda2c86ce62a48af7fbaff18dabc784d9ffbed63af9c64ead474777eee1a32485815d7b68c930551979cbd2df94cb74f6bd9209b

data/lib/bolt/cli.rb

@@ -394,8 +394,12 @@ Available options are:
       # After validation, initialize inventory and targets. Errors here are better to catch early.
       unless options[:action] == 'show'
         if options[:query]
+          if options[:nodes].any?
+            raise Bolt::CLIError, "Only one of '--nodes' or '--query' may be specified"
+          end
           nodes = query_puppetdb_nodes(options[:query])
           options[:targets] = inventory.get_targets(nodes)
+          options[:nodes] = nodes if options[:mode] == 'plan'
         else
           options[:targets] = inventory.get_targets(options[:nodes])
         end
@@ -532,6 +536,7 @@ Available options are:
           end
           options[:task_options]['nodes'] = options[:nodes].join(',')
         end
+
         params = options[:noop] ? options[:task_options].merge("_noop" => true) : options[:task_options]
         plan_context = { plan_name: options[:object],
                          params: params }

data/lib/bolt/puppetdb/client.rb

@@ -42,7 +42,7 @@ module Bolt
           fields = results.first&.keys
           raise Bolt::PuppetDBError, "Query results did not contain a 'certname' field: got #{fields.join(', ')}"
         end
-        results&.map { |result| result['certname'] }.uniq
+        results&.map { |result| result['certname'] }&.uniq
       end
 
       # This method expects an array of certnames to get facts for

data/lib/bolt/transport/ssh.rb

@@ -140,7 +140,7 @@ module Bolt
               dir.chown(conn.run_as)
 
               execute_options[:sudoable] = true if conn.run_as
-              output = conn.execute(command, **execute_options)
+              output = conn.execute(command, execute_options)
             end
             Bolt::Result.for_task(target, output.stdout.string,
                                   output.stderr.string,

data/lib/bolt/util/on_access.rb

@@ -10,7 +10,8 @@ module Bolt
 
       # If a method is called and we haven't constructed the object,
       # construct it. Then pass the call to the object.
-      # rubocop:disable Style/MethodMissing
+      # rubocop:disable Style/MethodMissingSuper
+      # rubocop:disable Style/MissingRespondToMissing
       def method_missing(method, *args, &block)
         if @obj.nil?
           @obj = @constructor.call
@@ -18,7 +19,8 @@ module Bolt
 
         @obj.send(method, *args, &block)
       end
-      # rubocop:enable Style/MethodMissing
+      # rubocop:enable Style/MethodMissingSuper
+      # rubocop:enable Style/MissingRespondToMissing
     end
   end
 end

data/lib/bolt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bolt
-  VERSION = '0.20.0'
+  VERSION = '0.20.2'
 end

data/vendored/facter/lib/facter.rb

@@ -0,0 +1,261 @@
+# Facter - Host Fact Detection and Reporting
+#
+# Copyright 2011 Puppet Labs Inc
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'facter/version'
+
+# Functions as a hash of 'facts' about your system system, such as MAC
+# address, IP address, architecture, etc.
+#
+# @example Retrieve a fact
+#     puts Facter['operatingsystem'].value
+#
+# @example Retrieve all facts
+#   Facter.to_hash
+#    => { "kernel"=>"Linux", "uptime_days"=>0, "ipaddress"=>"10.0.0.1" }
+#
+# @api public
+module Facter
+  # Most core functionality of facter is implemented in `Facter::Util`.
+  # @api public
+  module Util; end
+
+  require 'facter/util/fact'
+  require 'facter/util/collection'
+
+  include Comparable
+  include Enumerable
+
+  require 'facter/core/logging'
+  extend Facter::Core::Logging
+
+  # module methods
+
+  # Accessor for the collection object which holds all the facts
+  # @return [Facter::Util::Collection] the collection of facts
+  #
+  # @api private
+  def self.collection
+    unless defined?(@collection) and @collection
+      @collection = Facter::Util::Collection.new(
+        Facter::Util::Loader.new,
+        Facter::Util::Config.ext_fact_loader)
+    end
+    @collection
+  end
+
+  # Returns whether the JSON "feature" is available.
+  #
+  # @api private
+  def self.json?
+    begin
+      require 'json'
+      true
+    rescue LoadError
+      false
+    end
+  end
+
+  # Returns a fact object by name.  If you use this, you still have to
+  # call {Facter::Util::Fact#value `value`} on it to retrieve the actual
+  # value.
+  #
+  # @param name [String] the name of the fact
+  #
+  # @return [Facter::Util::Fact, nil] The fact object, or nil if no fact
+  #   is found.
+  #
+  # @api public
+  def self.[](name)
+    collection.fact(name)
+  end
+
+  # (see [])
+  def self.fact(name)
+    collection.fact(name)
+  end
+
+  # Flushes cached values for all facts. This does not cause code to be
+  # reloaded; it only clears the cached results.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.flush
+    collection.flush
+  end
+
+  # Lists all fact names
+  #
+  # @return [Array<String>] array of fact names
+  #
+  # @api public
+  def self.list
+    collection.list
+  end
+
+  # Gets the value for a fact. Returns `nil` if no such fact exists.
+  #
+  # @param name [String] the fact name
+  # @return [Object, nil] the value of the fact, or nil if no fact is
+  #   found
+  #
+  # @api public
+  def self.value(name)
+    collection.value(name)
+  end
+
+  # Gets a hash mapping fact names to their values
+  #
+  # @return [Hash{String => Object}] the hash of fact names and values
+  #
+  # @api public
+  def self.to_hash
+    collection.load_all
+    collection.to_hash
+  end
+
+  # Define a new fact or extend an existing fact.
+  #
+  # @param name [Symbol] The name of the fact to define
+  # @param options [Hash] A hash of options to set on the fact
+  #
+  # @return [Facter::Util::Fact] The fact that was defined
+  #
+  # @api public
+  # @see {Facter::Util::Collection#define_fact}
+  def self.define_fact(name, options = {}, &block)
+    collection.define_fact(name, options, &block)
+  end
+
+  # Adds a {Facter::Util::Resolution resolution} mechanism for a named
+  # fact. This does not distinguish between adding a new fact and adding
+  # a new way to resolve a fact.
+  #
+  # @overload add(name, options = {}, { || ... })
+  # @param name [String] the fact name
+  # @param options [Hash] optional parameters for the fact - attributes
+  #   of {Facter::Util::Fact} and {Facter::Util::Resolution} can be
+  #   supplied here
+  # @option options [Integer] :timeout set the
+  #   {Facter::Util::Resolution#timeout timeout} for this resolution
+  # @param block [Proc] a block defining a fact resolution
+  #
+  # @return [Facter::Util::Fact] the fact object, which includes any previously
+  #   defined resolutions
+  #
+  # @api public
+  def self.add(name, options = {}, &block)
+    collection.add(name, options, &block)
+  end
+
+  # Iterates over fact names and values
+  #
+  # @yieldparam [String] name the fact name
+  # @yieldparam [String] value the current value of the fact
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.each
+    # Make sure all facts are loaded.
+    collection.load_all
+
+    collection.each do |*args|
+      yield(*args)
+    end
+  end
+
+  # Clears all cached values and removes all facts from memory.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.clear
+    Facter.flush
+    Facter.reset
+  end
+
+  # Removes all facts from memory. Use this when the fact code has
+  # changed on disk and needs to be reloaded.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.reset
+    @collection = nil
+    reset_search_path!
+  end
+
+  # Loads all facts.
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.loadfacts
+    collection.load_all
+  end
+
+  # Register directories to be searched for facts. The registered directories
+  # must be absolute paths or they will be ignored.
+  #
+  # @param dirs [String] directories to search
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.search(*dirs)
+    @search_path += dirs
+  end
+
+  # Returns the registered search directories.
+  #
+  # @return [Array<String>] An array of the directories searched
+  #
+  # @api public
+  def self.search_path
+    @search_path.dup
+  end
+
+  # Reset the Facter search directories.
+  #
+  # @api private
+  # @return [void]
+  def self.reset_search_path!
+    @search_path = []
+  end
+
+  reset_search_path!
+
+  # Registers directories to be searched for external facts.
+  #
+  # @param dirs [Array<String>] directories to search
+  #
+  # @return [void]
+  #
+  # @api public
+  def self.search_external(dirs)
+    Facter::Util::Config.external_facts_dirs += dirs
+  end
+
+  # Returns the registered search directories.
+  #
+  # @return [Array<String>] An array of the directories searched
+  #
+  # @api public
+  def self.search_external_path
+    Facter::Util::Config.external_facts_dirs.dup
+  end
+end

data/vendored/facter/lib/facter/Cfkey.rb

@@ -0,0 +1,42 @@
+# Fact: cfkey
+#
+# Purpose: Return the public key(s) for CFengine.
+#
+# Resolution:
+#   Tries each file of standard `localhost.pub` and `cfkey.pub` locations,
+#   checks if they appear to be a public key, and then join them all together.
+#
+# Caveats:
+#
+
+## Cfkey.rb
+## Facts related to cfengine
+##
+
+Facter.add(:Cfkey) do
+  setcode do
+    value = nil
+    ["/usr/local/etc/cfkey.pub",
+      "/etc/cfkey.pub",
+      "/var/cfng/keys/localhost.pub",
+      "/var/cfengine/ppkeys/localhost.pub",
+      "/var/lib/cfengine/ppkeys/localhost.pub",
+      "/var/lib/cfengine2/ppkeys/localhost.pub"
+    ].each do |file|
+      if FileTest.file?(file)
+        File.open(file) { |openfile|
+          value = openfile.readlines.reject { |line|
+            line =~ /PUBLIC KEY/
+          }.collect { |line|
+            line.chomp
+          }.join("")
+        }
+      end
+      if value
+        break
+      end
+    end
+
+    value
+  end
+end

data/vendored/facter/lib/facter/application.rb

@@ -0,0 +1,206 @@
+require 'optparse'
+require 'facter'
+require 'facter/util/formatter'
+
+module Facter
+  module Application
+
+    require 'facter/util/nothing_loader'
+
+    def self.create_directory_loader(dir)
+      begin
+        Facter::Util::Config.ext_fact_loader = Facter::Util::DirectoryLoader.loader_for(dir)
+      rescue Facter::Util::DirectoryLoader::NoSuchDirectoryError => error
+        Facter.log_exception(error, "Specified external facts directory #{dir} does not exist.")
+        exit(1)
+      end
+    end
+
+    def self.create_nothing_loader
+      Facter::Util::Config.ext_fact_loader = Facter::Util::NothingLoader.new
+    end
+
+    def self.run(argv)
+      options = parse(argv)
+
+      # Accept fact names to return from the command line
+      names = argv
+
+      # Change location of external facts dir
+      # Check here for valid ext_dir and exit program
+
+      # Create the facts hash that is printed to standard out.
+      unless names.empty?
+        facts = {}
+        names.each do |name|
+          begin
+            facts[name] = Facter.value(name)
+          rescue => error
+            Facter.log_exception(error, "Could not retrieve #{name}: #{error.message}")
+            exit(10)
+          end
+        end
+      end
+
+      # Print everything if they didn't ask for specific facts.
+      facts ||= Facter.to_hash
+
+      output = nil
+
+      if options[:yaml]
+        output = Facter::Util::Formatter.format_yaml(facts)
+      elsif options[:json]
+        output = Facter::Util::Formatter.format_json(facts)
+      elsif options[:plaintext]
+        output = Facter::Util::Formatter.format_plaintext(facts)
+      else
+        output = Facter::Util::Formatter.format_plaintext(facts)
+      end
+
+      puts output
+      exit(0)
+
+    rescue => e
+      Facter.log_exception(e)
+      exit(12)
+    end
+
+    private
+
+    # Parses the given argument array destructively to return an options hash
+    # (and possibly perform side effects such as changing settings).
+    #
+    # @param [Array<String>] argv command line arguments
+    # @return [Hash] options hash
+    def self.parse(argv)
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = <<-BANNER
+facter(8) -- Gather system information
+======
+
+SYNOPSIS
+--------
+
+Collect and display facts about the system.
+
+USAGE
+-----
+
+    facter [-h|--help] [-t|--timing] [-d|--debug] [-p|--puppet] [-v|--version]
+      [-y|--yaml] [-j|--json] [--plaintext] [--external-dir DIR] [--no-external-dir]
+      [fact] [fact] [...]
+
+DESCRIPTION
+-----------
+
+Collect and display facts about the current system.  The library behind
+Facter is easy to expand, making Facter an easy way to collect information
+about a system from within the shell or within Ruby.
+
+If no facts are specifically asked for, then all facts will be returned.
+
+EXAMPLE
+-------
+
+Display all facts:
+
+    $ facter
+    architecture => amd64
+    blockdevices => sda,sr0
+    domain => example.com
+    fqdn => puppet.example.com
+    hardwaremodel => x86_64
+    [...]
+
+Display a single fact:
+
+    $ facter kernel
+    Linux
+
+Format facts as JSON:
+
+    $ facter --json architecture kernel hardwaremodel
+    {
+      "architecture": "amd64",
+      "kernel": "Linux",
+      "hardwaremodel": "x86_64"
+    }
+
+AUTHOR
+------
+  Luke Kanies
+
+COPYRIGHT
+---------
+  Copyright (c) 2011-2014 Puppet Labs, Inc Licensed under the Apache 2.0 license
+
+OPTIONS
+-------
+        BANNER
+        opts.on("-y",
+                "--yaml",
+                "Emit facts in YAML format.")   { |v| options[:yaml]   = v }
+        opts.on("-j",
+                "--json",
+                "Emit facts in JSON format.")   { |v| options[:json]   = v }
+        opts.on("--plaintext",
+                "Emit facts in plaintext format.") { |v| options[:plaintext] = v }
+        opts.on("--trace",
+                "Enable backtraces.")  { |v| Facter.trace(true) }
+        opts.on("--external-dir DIR",
+                "The directory to use for external facts.") { |v| create_directory_loader(v) }
+        opts.on("--no-external-dir",
+                "Turn off external facts.") { |v| create_nothing_loader }
+        opts.on("-d",
+                "--debug",
+                "Enable debugging.")  { |v| Facter.debugging(1) }
+        opts.on("-t",
+                "--timing",
+                "Enable timing.") { |v| Facter.timing(1) }
+        opts.on("-p",
+                "--puppet",
+                "(Deprecated: use `puppet facts` instead) Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.") do |v|
+          load_puppet
+        end
+
+        opts.on_tail("-v",
+                     "--version",
+                     "Print the version and exit.") do
+          puts Facter.version
+          exit(0)
+        end
+
+        opts.on_tail("-h",
+                     "--help",
+                     "Print this help message.") do
+          puts parser
+          exit(0)
+        end
+      end
+
+      parser.parse!(argv)
+
+      options
+    rescue OptionParser::InvalidOption => e
+      $stderr.puts e.message
+      exit(12)
+    end
+
+    def self.load_puppet
+      require 'puppet'
+      Puppet.initialize_settings
+
+      # If you've set 'vardir' but not 'libdir' in your
+      # puppet.conf, then the hook to add libdir to $:
+      # won't get triggered.  This makes sure that it's setup
+      # correctly.
+      unless $LOAD_PATH.include?(Puppet[:libdir])
+        $LOAD_PATH << Puppet[:libdir]
+      end
+    rescue LoadError => detail
+      $stderr.puts "Could not load Puppet: #{detail}"
+    end
+
+  end
+end