facter 2.1.0-x64-mingw32

data/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 & 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/lib/facter/application.rb

@@ -0,0 +1,204 @@
+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",
+                "Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.") { |v| load_puppet }
+
+        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.parse_config
+
+      # 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

data/lib/facter/architecture.rb

@@ -0,0 +1,50 @@
+# 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/lib/facter/augeasversion.rb

@@ -0,0 +1,28 @@
+# 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/lib/facter/blockdevices.rb

@@ -0,0 +1,105 @@
+# 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 seperated 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/lib/facter/core/aggregate.rb

@@ -0,0 +1,220 @@
+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