facter 1.7.6 → 2.0.1.rc1

data/lib/facter/application.rb

@@ -1,3 +1,7 @@
+require 'optparse'
+require 'facter'
+require 'facter/util/formatter'
+
 module Facter
   module Application
 
@@ -7,7 +11,7 @@ module Facter
       begin
         Facter::Util::Config.ext_fact_loader = Facter::Util::DirectoryLoader.loader_for(dir)
       rescue Facter::Util::DirectoryLoader::NoSuchDirectoryError => error
-        $stderr.puts "Specified external facts directory #{dir} does not exist."
+        Facter.log_exception(error, "Specified external facts directory #{dir} does not exist.")
         exit(1)
       end
     end
@@ -17,9 +21,6 @@ module Facter
     end
 
     def self.run(argv)
-      require 'optparse'
-      require 'facter'
-
       options = parse(argv)
 
       # Accept fact names to return from the command line
@@ -35,8 +36,8 @@ module Facter
           begin
             facts[name] = Facter.value(name)
           rescue => error
-            $stderr.puts "Could not retrieve #{name}: #{error}"
-            exit 10
+            Facter.log_exception(error, "Could not retrieve #{name}: #{error.message}")
+            exit(10)
           end
         end
       end
@@ -44,44 +45,24 @@ module Facter
       # Print everything if they didn't ask for specific facts.
       facts ||= Facter.to_hash
 
-      # Print the facts as YAML and exit
-      if options[:yaml]
-        require 'yaml'
-        puts YAML.dump(facts)
-        exit(0)
-      end
+      output = nil
 
-      # Print the facts as JSON and exit
-      if options[:json]
-        begin
-          require 'json'
-          puts JSON.dump(facts)
-          exit(0)
-        rescue LoadError
-          $stderr.puts "You do not have JSON support in your version of Ruby. JSON output disabled"
-          exit(1)
-        end
-      end
-
-      # Print the value of a single fact, otherwise print a list sorted by fact
-      # name and separated by "=>"
-      if facts.length == 1
-        if value = facts.values.first
-          puts value
-        end
+      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
-        facts.sort_by{ |fact| fact.first }.each do |name,value|
-          puts "#{name} => #{value}"
-        end
+        output = Facter::Util::Formatter.format_plaintext(facts)
       end
 
+      puts output
+      exit(0)
+
     rescue => e
-      if options && options[:trace]
-        raise e
-      else
-        $stderr.puts "Error: #{e}"
-        exit(12)
-      end
+      Facter.log_exception(e)
+      exit(12)
     end
 
     private
@@ -95,18 +76,23 @@ module Facter
       options = {}
       parser = OptionParser.new do |opts|
         opts.banner = <<-BANNER
-Synopsis
-========
+facter(8) -- Gather system information
+======
+
+SYNOPSIS
+--------
 
 Collect and display facts about the system.
 
-Usage
-=====
+USAGE
+-----
 
-  facter [-d|--debug] [-h|--help] [-p|--puppet] [-v|--version] [-y|--yaml] [-j|--json] [--external-dir DIR] [--no-external-dir] [fact] [fact] [...]
+    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
-===========
+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
@@ -115,19 +101,42 @@ about a system from within the shell or within Ruby.
 If no facts are specifically asked for, then all facts will be returned.
 
 EXAMPLE
-=======
-  facter kernel
+-------
+
+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-2012 Puppet Labs, Inc Licensed under the Apache 2.0 license
+---------
+  Copyright (c) 2011-2014 Puppet Labs, Inc Licensed under the Apache 2.0 license
 
-USAGE
-=====
+OPTIONS
+-------
         BANNER
         opts.on("-y",
                 "--yaml",
@@ -135,8 +144,10 @@ USAGE
         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| options[:trace]  = v }
+                "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",

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

data/lib/facter/core/directed_graph.rb

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