bolt 0.19.1 → 0.20.0

data/vendored/facter/lib/facter/vlans.rb

@@ -1,17 +0,0 @@
-# Fact: vlans
-#
-# Purpose: On Linux, return a list of all the VLANs on the system.
-#
-# Resolution: On Linux only, checks for and reads `/proc/net/vlan/config` and
-# parses it.
-#
-# Caveats:
-#
-require 'facter/util/vlans'
-
-Facter.add("vlans") do
-  confine :kernel => :linux
-  setcode do
-    Facter::Util::Vlans.get_vlans
-  end
-end

data/vendored/facter/lib/facter/xendomains.rb

@@ -1,20 +0,0 @@
-# Fact: xendomains
-#
-# Purpose: Return the list of Xen domains on the Dom0.
-#
-# Resolution:
-#   On a Xen Dom0 host, return a list of Xen domains using the `util/xendomains`
-#   library.
-#
-# Caveats:
-#
-require 'facter/util/xendomains'
-
-Facter.add("xendomains") do
-  confine :kernel => %w{Linux FreeBSD OpenBSD SunOS}
-  confine :virtual => 'xen0'
-
-  setcode do
-    Facter::Util::Xendomains.get_domains
-  end
-end

data/vendored/facter/lib/facter/zfs_version.rb

@@ -1,14 +0,0 @@
-require 'facter'
-
-Facter.add('zfs_version') do
-  setcode do
-    if Facter::Core::Execution.which('zfs')
-      zfs_help = Facter::Core::Execution.exec('zfs -? 2> /dev/null')
-      zfs_has_upgrade = zfs_help.match(/\A.*upgrade.*\z/m) unless zfs_help.nil?
-      if zfs_has_upgrade
-        zfs_v = Facter::Core::Execution.exec('zfs upgrade -v')
-        zfs_version = zfs_v.scan(/^\s+(\d+)\s+/m).flatten.last unless zfs_v.nil?
-      end
-    end
-  end
-end

data/vendored/facter/lib/facter/zonename.rb

@@ -1,6 +0,0 @@
-require 'facter'
-
-Facter.add('zonename') do
-  confine :kernel => :sunos
-  setcode('zonename')
-end

data/vendored/facter/lib/facter/zones.rb

@@ -1,18 +0,0 @@
-# Fact: zones_<ZONE>
-#
-# Purpose:
-#   Return the list of zones on the system and add one zones_ fact
-#   for each zone with its state e.g. `running`, `incomplete`, or `installed`.
-#
-# Resolution:
-#   Uses `usr/sbin/zoneadm list -cp` to get the list of zones in separate parsable
-#   lines with delimeter being `:` which is used to split the line string and get
-#   the zone details.
-#
-# Caveats:
-#   Only supported on Solaris 10 and up.
-#
-require 'facter/util/solaris_zones'
-if Facter.value(:kernel) == 'SunOS'
-  Facter::Util::SolarisZones.add_facts
-end

data/vendored/facter/lib/facter/zpool_version.rb

@@ -1,10 +0,0 @@
-require 'facter'
-
-Facter.add('zpool_version') do
-  setcode do
-    if Facter::Core::Execution.which('zpool')
-      zpool_v = Facter::Core::Execution.exec('zpool upgrade -v')
-      zpool_version = zpool_v.scan(/^\s+(\d+)\s+/m).flatten.last unless zpool_v.nil?
-    end
-  end
-end

data/vendored/hiera/lib/hiera.rb

@@ -1,119 +0,0 @@
-require 'yaml'
-
-class Hiera
-  require "hiera/error"
-  require "hiera/version"
-  require "hiera/config"
-  require "hiera/util"
-  require "hiera/util/win32"
-  require "hiera/backend"
-  require "hiera/console_logger"
-  require "hiera/puppet_logger"
-  require "hiera/noop_logger"
-  require "hiera/fallback_logger"
-  require "hiera/filecache"
-
-  class << self
-    attr_reader :logger
-
-    # Loggers are pluggable, just provide a class called
-    # Hiera::Foo_logger and respond to :warn and :debug
-    #
-    # See hiera-puppet for an example that uses the Puppet
-    # loging system instead of our own
-    def logger=(logger)
-      require "hiera/#{logger}_logger"
-
-      @logger = Hiera::FallbackLogger.new(
-        Hiera.const_get("#{logger.capitalize}_logger"),
-        Hiera::Console_logger)
-    rescue Exception => e
-      @logger = Hiera::Console_logger
-      warn("Failed to load #{logger} logger: #{e.class}: #{e}")
-    end
-
-    def warn(msg); @logger.warn(msg); end
-    def debug(msg); @logger.debug(msg); end
-  end
-
-  attr_reader :options, :config
-
-  # If the config option is a string its assumed to be a filename,
-  # else a hash of what would have been in the YAML config file
-  def initialize(options={})
-    config = options[:config]
-    if config.nil?
-      # Look in codedir first, then confdir
-      config = File.join(Util.code_dir, 'hiera.yaml')
-      config = File.join(Util.config_dir, 'hiera.yaml') unless File.exist?(config)
-    end
-    @config = Config.load(config)
-
-    Config.load_backends
-  end
-
-  # Calls the backends to do the actual lookup.
-  #
-  # The _scope_ can be anything that responds to `[]`, if you have input
-  # data like a Puppet Scope that does not you can wrap that data in a
-  # class that has a `[]` method that fetches the data from your source.
-  # See hiera-puppet for an example of this.
-  #
-  # The order-override will insert as first in the hierarchy a data source
-  # of your choice.
-  #
-  # Possible values for the _resolution_type_ parameter:
-  #
-  # - _:priority_ - This is the default. First found value is returned and no merge is performed
-  # - _:array_ - An array merge lookup assembles a value from every matching level of the hierarchy. It retrieves all
-  #     of the (string or array) values for a given key, then flattens them into a single array of unique values.
-  #     If _priority_ lookup can be thought of as a “default with overrides” pattern, _array_ merge lookup can be though
-  #     of as “default with additions.”
-  # - _:hash_ - A hash merge lookup assembles a value from every matching level of the hierarchy. It retrieves all of
-  #     the (hash) values for a given key, then merges the hashes into a single hash. Hash merge lookups will fail with
-  #     an error if any of the values found in the data sources are strings or arrays. It only works when every value
-  #     found is a hash. The actual merge behavior is determined by looking up the keys `:merge_behavior` and
-  #     `:deep_merge_options` in the Hiera config. `:merge_behavior` can be set to `:deep`, :deeper` or `:native`
-  #     (explained in detail below).
-  # - _{ deep merge options }_ - Configured values for `:merge_behavior` and `:deep_merge_options`will be completely
-  #     ignored. Instead the _resolution_type_ will be a `:hash` merge where the `:merge_behavior` will be the value
-  #     keyed by `:behavior` in the given hash and the `:deep_merge_options` will be the remaining top level entries of
-  #     that same hash.
-  #
-  # Valid behaviors for the _:hash_ resolution type:
-  #
-  # - _native_ - Performs a simple hash-merge by overwriting keys of lower lookup priority.
-  # - _deeper_ - In a deeper hash merge, Hiera recursively merges keys and values in each source hash. For each key,
-  #     if the value is:
-  #        - only present in one source hash, it goes into the final hash.
-  #        - a string/number/boolean and exists in two or more source hashes, the highest priority value goes into
-  #          the final hash.
-  #        - an array and exists in two or more source hashes, the values from each source are merged into a single
-  #          array and de-duplicated (but not automatically flattened, as in an array merge lookup).
-  #        - a hash and exists in two or more source hashes, the values from each source are recursively merged, as
-  #          though they were source hashes.
-  #        - mismatched between two or more source hashes, we haven’t validated the behavior. It should act as
-  #          described in the deep_merge gem documentation.
-  # - _deep_ - In a deep hash merge, Hiera behaves the same as for _deeper_, except that when a string/number/boolean
-  #     exists in two or more source hashes, the lowest priority value goes into the final hash. This is considered
-  #     largely useless and should be avoided. Use _deeper_ instead.
-  #
-  # The _merge_ can be given as a hash with the mandatory key `:strategy` to denote the actual strategy. This
-  # is useful for the `:deeper` and `:deep` strategy since they can use additional options to control the behavior.
-  # The options can be passed as top level keys in the `merge` parameter when it is a given as a hash. Recognized
-  # options are:
-  #
-  #  - 'knockout_prefix' Set to string value to signify prefix which deletes elements from existing element. Defaults is _undef_
-  #  - 'sort_merged_arrays' Set to _true_ to sort all arrays that are merged together. Default is _false_
-  #  - 'merge_hash_arrays' Set to _true_ to merge hashes within arrays. Default is _false_
-  #
-  # @param key [String] The key to lookup
-  # @param default [Object,nil] The value to return when there is no match for _key_
-  # @param scope [#[],nil] The scope to use for the lookup
-  # @param order_override [#[]] An override that will considered the first source of lookup
-  # @param resolution_type [String,Hash<Symbol,String>] Symbolic resolution type or deep merge configuration
-  # @return [Object] The found value or the given _default_ value
-  def lookup(key, default, scope, order_override=nil, resolution_type=:priority)
-    Backend.lookup(key, default, scope, order_override, resolution_type)
-  end
-end

data/vendored/hiera/lib/hiera/backend.rb

@@ -1,360 +0,0 @@
-require 'hiera/util'
-require 'hiera/interpolate'
-
-begin
-  require 'deep_merge/rails_compat'
-rescue LoadError
-end
-
-class Hiera
-  module Backend
-    class Backend1xWrapper
-      def initialize(wrapped)
-        @wrapped = wrapped
-      end
-
-      def lookup(key, scope, order_override, resolution_type, context)
-        Hiera.debug("Using Hiera 1.x backend API to access instance of class #{@wrapped.class.name}. Lookup recursion will not be detected")
-        value = @wrapped.lookup(key, scope, order_override, resolution_type.is_a?(Hash) ? :hash : resolution_type)
-
-        # The most likely cause when an old backend returns nil is that the key was not found. In any case, it is
-        # impossible to know the difference between that and a found nil. The throw here preserves the old behavior.
-        throw (:no_such_key) if value.nil?
-        value
-      end
-    end
-
-    class << self
-      # Data lives in /var/lib/hiera by default.  If a backend
-      # supplies a datadir in the config it will be used and
-      # subject to variable expansion based on scope
-      def datadir(backend, scope)
-        backend = backend.to_sym
-
-        if Config[backend] && Config[backend][:datadir]
-          dir = Config[backend][:datadir]
-        else
-          dir = Hiera::Util.var_dir
-        end
-
-        if !dir.is_a?(String)
-          raise(Hiera::InvalidConfigurationError,
-                "datadir for #{backend} cannot be an array")
-        end
-
-        interpolate_config(dir, scope, nil)
-      end
-
-      # Finds the path to a datafile based on the Backend#datadir
-      # and extension
-      #
-      # If the file is not found nil is returned
-      def datafile(backend, scope, source, extension)
-        datafile_in(datadir(backend, scope), source, extension)
-      end
-
-      # @api private
-      def datafile_in(datadir, source, extension)
-        file = File.join(datadir, "#{source}.#{extension}")
-
-        if File.exist?(file)
-          file
-        else
-          Hiera.debug("Cannot find datafile #{file}, skipping")
-          nil
-        end
-      end
-
-      # Constructs a list of data sources to search
-      #
-      # If you give it a specific hierarchy it will just use that
-      # else it will use the global configured one, failing that
-      # it will just look in the 'common' data source.
-      #
-      # An override can be supplied that will be pre-pended to the
-      # hierarchy.
-      #
-      # The source names will be subject to variable expansion based
-      # on scope
-      def datasources(scope, override=nil, hierarchy=nil)
-        if hierarchy
-          hierarchy = [hierarchy]
-        elsif Config.include?(:hierarchy)
-          hierarchy = [Config[:hierarchy]].flatten
-        else
-          hierarchy = ["common"]
-        end
-
-        hierarchy.insert(0, override) if override
-
-        hierarchy.flatten.map do |source|
-          source = interpolate_config(source, scope, override)
-          if source == "" or source =~ /(^\/|\/\/|\/$)/
-            Hiera.debug("Ignoring bad definition in :hierarchy: \'#{source}\'")
-          else
-            yield(source)
-          end
-        end
-      end
-
-      # Constructs a list of data files to search
-      #
-      # If you give it a specific hierarchy it will just use that
-      # else it will use the global configured one, failing that
-      # it will just look in the 'common' data source.
-      #
-      # An override can be supplied that will be pre-pended to the
-      # hierarchy.
-      #
-      # The source names will be subject to variable expansion based
-      # on scope
-      #
-      # Only files that exist will be returned. If the file is missing, then
-      # the block will not receive the file.
-      #
-      # @yield [String, String] the source string and the name of the resulting file
-      # @api public
-      def datasourcefiles(backend, scope, extension, override=nil, hierarchy=nil)
-        datadir = Backend.datadir(backend, scope)
-        Backend.datasources(scope, override, hierarchy) do |source|
-          Hiera.debug("Looking for data source #{source}")
-          file = datafile_in(datadir, source, extension)
-
-          if file
-            yield source, file
-          end
-        end
-      end
-
-      # Parse a string like <code>'%{foo}'</code> against a supplied
-      # scope and additional scope.  If either scope or
-      # extra_scope includes the variable 'foo', then it will
-      # be replaced else an empty string will be placed.
-      #
-      # If both scope and extra_data has "foo", then the value in scope
-      # will be used.
-      #
-      # @param data [String] The string to perform substitutions on.
-      #   This will not be modified, instead a new string will be returned.
-      # @param scope [#[]] The primary source of data for substitutions.
-      # @param extra_data [#[]] The secondary source of data for substitutions.
-      # @param context [#[]] Context can include :recurse_guard and :order_override.
-      # @return [String] A copy of the data with all instances of <code>%{...}</code> replaced.
-      #
-      # @api public
-      def parse_string(data, scope, extra_data={}, context={:recurse_guard => nil, :order_override => nil})
-        Hiera::Interpolate.interpolate(data, scope, extra_data, context)
-      end
-
-      # Parses a answer received from data files
-      #
-      # Ultimately it just pass the data through parse_string but
-      # it makes some effort to handle arrays of strings as well
-      def parse_answer(data, scope, extra_data={}, context={:recurse_guard => nil, :order_override => nil})
-        if data.is_a?(Numeric) or data.is_a?(TrueClass) or data.is_a?(FalseClass)
-          return data
-        elsif data.is_a?(String)
-          return parse_string(data, scope, extra_data, context)
-        elsif data.is_a?(Hash)
-          answer = {}
-          data.each_pair do |key, val|
-            interpolated_key = parse_string(key, scope, extra_data, context)
-            answer[interpolated_key] = parse_answer(val, scope, extra_data, context)
-          end
-
-          return answer
-        elsif data.is_a?(Array)
-          answer = []
-          data.each do |item|
-            answer << parse_answer(item, scope, extra_data, context)
-          end
-
-          return answer
-        end
-      end
-
-      def resolve_answer(answer, resolution_type)
-        case resolution_type
-        when :array
-          [answer].flatten.uniq.compact
-        when :hash
-          answer # Hash structure should be preserved
-        else
-          answer
-        end
-      end
-
-      # Merges two hashes answers with the given or configured merge behavior. Behavior can be given
-      # by passing _resolution_type_ as a Hash
-      #
-      #  :merge_behavior: {:native|:deep|:deeper}
-      #
-      # Deep merge options use the Hash utility function provided by [deep_merge](https://github.com/danielsdeleo/deep_merge)
-      # It uses the compatibility mode [deep_merge](https://github.com/danielsdeleo/deep_merge#using-deep_merge-in-rails)
-      #
-      #  :native => Native Hash.merge
-      #  :deep   => Use Hash.deeper_merge
-      #  :deeper => Use Hash.deeper_merge!
-      #
-      # @param left [Hash] left side of the merge
-      # @param right [Hash] right side of the merge
-      # @param resolution_type [String,Hash] The merge type, or if hash, the merge behavior and options
-      # @return [Hash] The merged result
-      # @see Hiera#lookup
-      #
-      def merge_answer(left,right,resolution_type=nil)
-        behavior, options =
-          if resolution_type.is_a?(Hash)
-            merge = resolution_type.clone
-            [merge.delete(:behavior), merge]
-          else
-            [Config[:merge_behavior], Config[:deep_merge_options] || {}]
-          end
-
-        case behavior
-        when :deeper,'deeper'
-          left.deeper_merge!(right, options)
-        when :deep,'deep'
-          left.deeper_merge(right, options)
-        else # Native and undefined
-          left.merge(right)
-        end
-      end
-
-      # Calls out to all configured backends in the order they
-      # were specified.  The first one to answer will win.
-      #
-      # This lets you declare multiple backends, a possible
-      # use case might be in Puppet where a Puppet module declares
-      # default data using in-module data while users can override
-      # using JSON/YAML etc.  By layering the backends and putting
-      # the Puppet one last you can override module author data
-      # easily.
-      #
-      # Backend instances are cached so if you need to connect to any
-      # databases then do so in your constructor, future calls to your
-      # backend will not create new instances
-
-      # @param key [String] The key to lookup. May be quoted with single or double quotes to avoid subkey traversal on dot characters
-      # @param scope [#[]] The primary source of data for substitutions.
-      # @param order_override [#[],nil] An override that will be pre-pended to the hierarchy definition.
-      # @param resolution_type [Symbol,Hash,nil] One of :hash, :array,:priority or a Hash with deep merge behavior and options
-      # @param context [#[]] Context used for internal processing
-      # @return [Object] The value that corresponds to the given key or nil if no such value cannot be found
-      #
-      def lookup(key, default, scope, order_override, resolution_type, context = {:recurse_guard => nil})
-        @backends ||= {}
-        answer = nil
-
-        # order_override is kept as an explicit argument for backwards compatibility, but should be specified
-        # in the context for internal handling.
-        context ||= {}
-        order_override ||= context[:order_override]
-        context[:order_override] ||= order_override
-
-        strategy = resolution_type.is_a?(Hash) ? :hash : resolution_type
-
-        segments = Util.split_key(key) { |problem| ArgumentError.new("#{problem} in key: #{key}") }
-        subsegments = nil
-        if segments.size > 1
-          unless strategy.nil? || strategy == :priority
-            raise ArgumentError, "Resolution type :#{strategy} is illegal when accessing values using dotted keys. Offending key was '#{key}'"
-          end
-          subsegments = segments.drop(1)
-        end
-
-        found = false
-        Config[:backends].each do |backend|
-          backend_constant = "#{backend.capitalize}_backend"
-          if constants.include?(backend_constant) || constants.include?(backend_constant.to_sym)
-            backend = (@backends[backend] ||= find_backend(backend_constant))
-            found_in_backend = false
-            new_answer = catch(:no_such_key) do
-              if subsegments.nil? 
-                value = backend.lookup(segments[0], scope, order_override, resolution_type, context)
-              elsif backend.respond_to?(:lookup_with_segments)
-                value = backend.lookup_with_segments(segments, scope, order_override, resolution_type, context)
-              else
-                value = backend.lookup(segments[0], scope, order_override, resolution_type, context)
-                value = qualified_lookup(subsegments, value, key) unless subsegments.nil?
-              end
-              found_in_backend = true
-              value
-            end
-            next unless found_in_backend
-            found = true
-
-            case strategy
-            when :array
-              raise Exception, "Hiera type mismatch for key '#{key}': expected Array and got #{new_answer.class}" unless new_answer.kind_of? Array or new_answer.kind_of? String
-              answer ||= []
-              answer << new_answer
-            when :hash
-              raise Exception, "Hiera type mismatch for key '#{key}': expected Hash and got #{new_answer.class}" unless new_answer.kind_of? Hash
-              answer ||= {}
-              answer = merge_answer(new_answer, answer, resolution_type)
-            else
-              answer = new_answer
-              break
-            end
-          end
-        end
-
-        answer = resolve_answer(answer, strategy) unless answer.nil?
-        answer = parse_string(default, scope, {}, context) if !found && default.is_a?(String)
-
-        return default if !found && answer.nil?
-        return answer
-      end
-
-      def clear!
-        @backends = {}
-      end
-
-      def qualified_lookup(segments, hash, full_key = nil)
-        value = hash
-        segments.each do |segment|
-          throw :no_such_key if value.nil?
-          if segment =~ /^[0-9]+$/
-            segment = segment.to_i
-            unless value.instance_of?(Array)
-              suffix = full_key.nil? ? '' : " from key '#{full_key}'"
-              raise Exception,
-                "Hiera type mismatch: Got #{value.class.name} when Array was expected to access value using '#{segment}'#{suffix}"
-            end
-            throw :no_such_key unless segment < value.size
-          else
-            unless value.respond_to?(:'[]') && !(value.instance_of?(Array) || value.instance_of?(String))
-              suffix = full_key.nil? ? '' : " from key '#{full_key}'"
-              raise Exception,
-                "Hiera type mismatch: Got #{value.class.name} when a hash-like object was expected to access value using '#{segment}'#{suffix}"
-            end
-            throw :no_such_key unless value.include?(segment)
-          end
-          value = value[segment]
-        end
-        value
-      end
-
-      def find_backend(backend_constant)
-        backend = Backend.const_get(backend_constant).new
-        return backend.method(:lookup).arity == 4 ? Backend1xWrapper.new(backend) : backend
-      end
-      private :find_backend
-
-      def interpolate_config(entry, scope, override)
-        if @config_lookup_context.nil?
-          @config_lookup_context = { :is_interpolate_config => true, :order_override => override, :recurse_guard => Hiera::RecursiveGuard.new }
-          begin
-            Hiera::Interpolate.interpolate(entry, scope, {}, @config_lookup_context)
-          ensure
-            @config_lookup_context = nil
-          end
-        else
-          # Nested call (will happen when interpolate method 'hiera' is used)
-          Hiera::Interpolate.interpolate(entry, scope, {}, @config_lookup_context.merge(:order_override => override))
-        end
-      end
-    end
-  end
-end