bolt 0.19.1 → 0.20.0

data/vendored/facter/lib/facter/architecture.rb

@@ -1,50 +0,0 @@
-# Fact: architecture
-#
-# Purpose:
-#   Return the CPU hardware architecture.
-#
-# Resolution:
-#   On non-AIX IBM, OpenBSD, Linux, and Debian's kfreebsd, use the hardwaremodel fact.
-#   On AIX get the arch value from `lsattr -El proc0 -a type`.
-#   Gentoo and Debian call "x86_86" "amd64".
-#   Gentoo also calls "i386" "x86".
-#
-# Caveats:
-#
-
-require 'facter/util/architecture'
-
-Facter.add(:architecture) do
-  setcode do
-    model = Facter.value(:hardwaremodel)
-    case model
-      # most linuxen use "x86_64"
-    when /IBM*/
-      case Facter.value(:operatingsystem)
-      when "AIX"
-         arch = Facter::Util::Architecture.lsattr
-         if (match = arch.match /type\s(\S+)\s/)
-           match[1]
-         end
-      else
-        model
-      end
-    when "x86_64"
-      case Facter.value(:operatingsystem)
-      when "Debian", "Gentoo", "GNU/kFreeBSD", "Ubuntu"
-        "amd64"
-      else
-        model
-      end
-    when /(i[3456]86|pentium)/
-      case Facter.value(:operatingsystem)
-      when "Gentoo", "windows"
-        "x86"
-      else
-        "i386"
-      end
-    else
-      model
-    end
-  end
-end

data/vendored/facter/lib/facter/augeasversion.rb

@@ -1,28 +0,0 @@
-# Fact: augeasversion
-#
-# Purpose: Report the version of the Augeas library.
-#
-# Resolution:
-#   Loads ruby-augeas and reports the value of `/augeas/version`, the version of
-#   the underlying Augeas library.
-#
-# Caveats:
-#   The library version may not indicate the presence of certain lenses,
-#   depending on the system packages updated, nor the version of ruby-augeas
-#   which may affect support for the Puppet Augeas provider.
-#   Versions prior to 0.3.6 cannot be interrogated for their version.
-#
-
-Facter.add(:augeasversion) do
-  setcode do
-    begin
-      require 'augeas'
-      aug = Augeas::open('/', nil, Augeas::NO_MODL_AUTOLOAD)
-      ver = aug.get('/augeas/version')
-      aug.close
-      ver
-    rescue Exception
-      Facter.debug('ruby-augeas not available')
-    end
-  end
-end

data/vendored/facter/lib/facter/blockdevices.rb

@@ -1,105 +0,0 @@
-# Fact: blockdevice_<devicename>_size
-#
-# Purpose:
-#   Return the size of a block device in bytes.
-#
-# Resolution:
-#   Parse the contents of `/sys/block/<device>/size` to receive the size (multiplying by 512 to correct for blocks-to-bytes).
-#
-# Caveats:
-#   Only supports Linux 2.6+ at this time, due to the reliance on sysfs.
-#
-
-# Fact: blockdevice_<devicename>_vendor
-#
-# Purpose:
-#   Return the vendor name of block devices attached to the system.
-#
-# Resolution:
-#   Parse the contents of `/sys/block/<device>/device/vendor` to retrieve the vendor for a device.
-#
-# Caveats:
-#   Only supports Linux 2.6+ at this time, due to the reliance on sysfs.
-#
-
-# Fact: blockdevice_<devicename>_model
-#
-# Purpose:
-#   Return the model name of block devices attached to the system.
-#
-# Resolution:
-#   Parse the contents of `/sys/block/<device>/device/model` to retrieve the model name/number for a device.
-#
-# Caveats:
-#   Only supports Linux 2.6+ at this time, due to the reliance on sysfs.
-#
-
-
-# Fact: blockdevices
-#
-# Purpose:
-#   Return a comma separated list of block devices.
-#
-# Resolution:
-#   Retrieve the block devices that were identified and iterated over in the creation of the blockdevice_ facts.
-#
-# Caveats:
-#   Block devices must have been identified using sysfs information.
-#
-
-# Author: Jason Gill <jasongill@gmail.com>
-
-require 'facter'
-
-# Only Linux 2.6+ kernels support sysfs which is required to easily get device details
-if Facter.value(:kernel) == 'Linux'
-
-  sysfs_block_directory = '/sys/block/'
-
-  blockdevices = []
-
-  # This should prevent any non-2.6 kernels or odd machines without sysfs support from being investigated further
-  if File.exist?(sysfs_block_directory)
-
-    # Iterate over each file in the /sys/block/ directory and skip ones that do not have a device subdirectory
-    Dir.entries(sysfs_block_directory).each do |device|
-      sysfs_device_directory = sysfs_block_directory + device + "/device"
-      next unless File.exist?(sysfs_device_directory)
-
-      # Add the device to the blockdevices list, which is returned as it's own fact later on
-      blockdevices << device
-
-      sizefile = sysfs_block_directory + device + "/size"
-      vendorfile = sysfs_device_directory + "/vendor"
-      modelfile = sysfs_device_directory + "/model"
-
-      if File.exist?(sizefile)
-        Facter.add("blockdevice_#{device}_size".to_sym) do
-          setcode { IO.read(sizefile).strip.to_i * 512 }
-        end
-      end
-
-      if File.exist?(vendorfile)
-        Facter.add("blockdevice_#{device}_vendor".to_sym) do
-          setcode { IO.read(vendorfile).strip }
-        end
-      end
-
-      if File.exist?(modelfile)
-        Facter.add("blockdevice_#{device}_model".to_sym) do
-          setcode { IO.read(modelfile).strip }
-        end
-      end
-
-    end
-
-  end
-
-  # Return a comma-seperated list of block devices found
-  unless blockdevices.empty?
-    Facter.add(:blockdevices) do
-      setcode { blockdevices.sort.join(',') }
-    end
-  end
-
-end

data/vendored/facter/lib/facter/core/aggregate.rb

@@ -1,220 +0,0 @@
-require 'facter'
-require 'facter/core/directed_graph'
-require 'facter/core/suitable'
-require 'facter/core/resolvable'
-require 'facter/util/values'
-
-# Aggregates provide a mechanism for facts to be resolved in multiple steps.
-#
-# Aggregates are evaluated in two parts: generating individual chunks and then
-# aggregating all chunks together. Each chunk is a block of code that generates
-# a value, and may depend on other chunks when it runs. After all chunks have
-# been evaluated they are passed to the aggregate block as Hash<name, result>.
-# The aggregate block converts the individual chunks into a single value that is
-# returned as the final value of the aggregate.
-#
-# @api public
-# @since 2.0.0
-class Facter::Core::Aggregate
-
-  include Facter::Core::Suitable
-  include Facter::Core::Resolvable
-
-  # @!attribute [r] name
-  #   @return [Symbol] The name of the aggregate resolution
-  attr_reader :name
-
-  # @!attribute [r] deps
-  #   @api private
-  #   @return [Facter::Core::DirectedGraph]
-  attr_reader :deps
-
-  # @!attribute [r] confines
-  #   @return [Array<Facter::Core::Confine>] An array of confines restricting
-  #     this to a specific platform
-  #   @see Facter::Core::Suitable
-  attr_reader :confines
-
-  # @!attribute [r] fact
-  # @return [Facter::Util::Fact]
-  # @api private
-  attr_reader :fact
-
-  def initialize(name, fact)
-    @name = name
-    @fact = fact
-
-    @confines = []
-    @chunks = {}
-
-    @aggregate = nil
-    @deps = Facter::Core::DirectedGraph.new
-  end
-
-  def set_options(options)
-    if options[:name]
-      @name = options.delete(:name)
-    end
-
-    if options.has_key?(:timeout)
-      @timeout = options.delete(:timeout)
-    end
-
-    if options.has_key?(:weight)
-      @weight = options.delete(:weight)
-    end
-
-    if not options.keys.empty?
-      raise ArgumentError, "Invalid aggregate options #{options.keys.inspect}"
-    end
-  end
-
-  def evaluate(&block)
-    instance_eval(&block)
-  end
-
-  # Define a new chunk for the given aggregate
-  #
-  # @api public
-  #
-  # @example Defining a chunk with no dependencies
-  #   aggregate.chunk(:mountpoints) do
-  #     # generate mountpoint information
-  #   end
-  #
-  # @example Defining an chunk to add mount options
-  #   aggregate.chunk(:mount_options, :require => [:mountpoints]) do |mountpoints|
-  #     # `mountpoints` is the result of the previous chunk
-  #     # generate mount option information based on the mountpoints
-  #   end
-  #
-  # @param name [Symbol] A name unique to this aggregate describing the chunk
-  # @param opts [Hash]
-  # @options opts [Array<Symbol>, Symbol] :require One or more chunks
-  #   to evaluate and pass to this block.
-  # @yield [*Object] Zero or more chunk results
-  #
-  # @return [void]
-  def chunk(name, opts = {}, &block)
-    if not block_given?
-      raise ArgumentError, "#{self.class.name}#chunk requires a block"
-    end
-
-    deps = Array(opts.delete(:require))
-
-    if not opts.empty?
-      raise ArgumentError, "Unexpected options passed to #{self.class.name}#chunk: #{opts.keys.inspect}"
-    end
-
-    @deps[name] = deps
-    @chunks[name] = block
-  end
-
-  # Define how all chunks should be combined
-  #
-  # @api public
-  #
-  # @example Merge all chunks
-  #   aggregate.aggregate do |chunks|
-  #     final_result = {}
-  #     chunks.each_value do |chunk|
-  #       final_result.deep_merge(chunk)
-  #     end
-  #     final_result
-  #   end
-  #
-  # @example Sum all chunks
-  #   aggregate.aggregate do |chunks|
-  #     total = 0
-  #     chunks.each_value do |chunk|
-  #       total += chunk
-  #     end
-  #     total
-  #   end
-  #
-  # @yield [Hash<Symbol, Object>] A hash containing chunk names and
-  #   chunk values
-  #
-  # @return [void]
-  def aggregate(&block)
-    if block_given?
-      @aggregate = block
-    else
-      raise ArgumentError, "#{self.class.name}#aggregate requires a block"
-    end
-  end
-
-  def resolution_type
-    :aggregate
-  end
-
-  private
-
-  # Evaluate the results of this aggregate.
-  #
-  # @see Facter::Core::Resolvable#value
-  # @return [Object]
-  def resolve_value
-    chunk_results = run_chunks()
-    aggregate_results(chunk_results)
-  end
-
-  # Order all chunks based on their dependencies and evaluate each one, passing
-  # dependent chunks as needed.
-  #
-  # @return [Hash<Symbol, Object>] A hash containing the chunk that
-  #   generated value and the related value.
-  def run_chunks
-    results = {}
-    order_chunks.each do |(name, block)|
-      input = @deps[name].map { |dep_name| results[dep_name] }
-
-      output = block.call(*input)
-      results[name] = Facter::Util::Values.deep_freeze(output)
-    end
-
-    results
-  end
-
-  # Process the results of all chunks with the aggregate block and return the
-  # results. If no aggregate block has been specified, fall back to deep
-  # merging the given data structure
-  #
-  # @param results [Hash<Symbol, Object>] A hash of chunk names and the output
-  #   of that chunk.
-  # @return [Object]
-  def aggregate_results(results)
-    if @aggregate
-      @aggregate.call(results)
-    else
-      default_aggregate(results)
-    end
-  end
-
-  def default_aggregate(results)
-    results.values.inject do |result, current|
-      Facter::Util::Values.deep_merge(result, current)
-    end
-  rescue Facter::Util::Values::DeepMergeError => e
-    raise ArgumentError, "Could not deep merge all chunks (Original error: " +
-      "#{e.message}), ensure that chunks return either an Array or Hash or " +
-      "override the aggregate block", e.backtrace
-  end
-
-  # Order chunks based on their dependencies
-  #
-  # @return [Array<Symbol, Proc>] A list of chunk names and blocks in evaluation order.
-  def order_chunks
-    if not @deps.acyclic?
-      raise DependencyError, "Could not order chunks; found the following dependency cycles: #{@deps.cycles.inspect}"
-    end
-
-    sorted_names = @deps.tsort
-
-    sorted_names.map do |name|
-      [name, @chunks[name]]
-    end
-  end
-
-  class DependencyError < StandardError; end
-end

data/vendored/facter/lib/facter/core/directed_graph.rb

@@ -1,46 +0,0 @@
-require 'set'
-require 'tsort'
-
-module Facter
-  module Core
-    class DirectedGraph < Hash
-      include TSort
-
-      def acyclic?
-        cycles.empty?
-      end
-
-      def cycles
-        cycles = []
-        each_strongly_connected_component do |component|
-          cycles << component if component.size > 1
-        end
-        cycles
-      end
-
-      alias tsort_each_node each_key
-
-      def tsort_each_child(node)
-        fetch(node, []).each do |child|
-          yield child
-        end
-      end
-
-      def tsort
-        missing = Set.new(self.values.flatten) - Set.new(self.keys)
-
-        if not missing.empty?
-          raise MissingVertex, "Cannot sort elements; cannot depend on missing elements #{missing.to_a}"
-        end
-
-        super
-
-      rescue TSort::Cyclic
-        raise CycleError, "Cannot sort elements; found the following cycles: #{cycles.inspect}"
-      end
-
-      class CycleError < StandardError; end
-      class MissingVertex < StandardError; end
-    end
-  end
-end