facter 1.7.6 → 2.0.1.rc1

data/lib/facter/util/confine.rb

@@ -10,19 +10,40 @@ class Facter::Util::Confine
 
   # Add the restriction.  Requires the fact name, an operator, and the value
   # we're comparing to.
-  def initialize(fact, *values)
-    raise ArgumentError, "The fact name must be provided" unless fact
-    raise ArgumentError, "One or more values must be provided" if values.empty?
+  #
+  # @param fact [Symbol] Name of the fact
+  # @param values [Array] One or more values to match against.
+  #   They can be any type that provides a === method.
+  # @param block [Proc] Alternatively a block can be supplied as a check.  The fact
+  #   value will be passed as the argument to the block.  If the block returns
+  #   true then the fact will be enabled, otherwise it will be disabled.
+  def initialize(fact = nil, *values, &block)
+    raise ArgumentError, "The fact name must be provided" unless fact or block_given?
+    if values.empty? and not block_given?
+      raise ArgumentError, "One or more values or a block must be provided"
+    end
     @fact = fact
     @values = values
+    @block = block
   end
 
   def to_s
+    return @block.to_s if @block
     return "'%s' '%s'" % [@fact, @values.join(",")]
   end
 
   # Evaluate the fact, returning true or false.
+  # if we have a block paramter then we only evaluate that instead
   def true?
+    if @block and not @fact then
+      begin
+        return !! @block.call
+      rescue StandardError => error
+        Facter.debug "Confine raised #{error.class} #{error}"
+        return false
+      end
+    end
+
     unless fact = Facter[@fact]
       Facter.debug "No fact for %s" % @fact
       return false
@@ -31,6 +52,15 @@ class Facter::Util::Confine
 
     return false if value.nil?
 
-    return @values.any? { |v| convert(v) === value }
+    if @block then
+      begin
+        return !! @block.call(value)
+      rescue StandardError => error
+        Facter.debug "Confine raised #{error.class} #{error}"
+        return false
+      end
+    end
+
+    return @values.any? do |v| convert(v) === value end
   end
 end

data/lib/facter/util/ec2.rb

@@ -52,7 +52,7 @@ module Facter::Util::EC2
                       "arp -an"
                     end
 
-      if arp_table = Facter::Util::Resolution.exec(arp_command)
+      if arp_table = Facter::Core::Execution.exec(arp_command)
         return true if arp_table.match(mac_address_re)
       end
       return false

data/lib/facter/util/fact.rb

@@ -1,24 +1,33 @@
 require 'facter'
 require 'facter/util/resolution'
-
+require 'facter/core/aggregate'
+
+# This class represents a fact. Each fact has a name and multiple
+# {Facter::Util::Resolution resolutions}.
+#
+# Create facts using {Facter.add}
+#
+# @api public
 class Facter::Util::Fact
-  TIMEOUT = 5
-
-  attr_accessor :name, :ldapname
-
-  # Create a new fact, with no resolution mechanisms.
+  # The name of the fact
+  # @return [String]
+  attr_accessor :name
+
+  # @return [String]
+  # @deprecated
+  attr_accessor :ldapname
+
+  # Creates a new fact, with no resolution mechanisms. See {Facter.add}
+  # for the public API for creating facts.
+  # @param name [String] the fact name
+  # @param options [Hash] optional parameters
+  # @option options [String] :ldapname set the ldapname property on the fact
+  #
+  # @api private
   def initialize(name, options = {})
     @name = name.to_s.downcase.intern
 
-    # LAK:NOTE: This is slow for many options, but generally we won't have any and at
-    # worst we'll have one.  If we add more, this should be made more efficient.
-    options.each do |name, value|
-      case name
-      when :ldapname; self.ldapname = value
-      else
-        raise ArgumentError, "Invalid fact option '%s'" % name
-      end
-    end
+    extract_ldapname_option!(options)
 
     @ldapname ||= @name.to_s
 
@@ -28,33 +37,68 @@ class Facter::Util::Fact
     @value = nil
   end
 
-  # Add a new resolution mechanism.  This requires a block, which will then
-  # be evaluated in the context of the new mechanism.
-  def add(value = nil, &block)
-    begin
-      resolve = Facter::Util::Resolution.new(@name)
+  # Adds a new {Facter::Util::Resolution resolution}.  This requires a
+  # block, which will then be evaluated in the context of the new
+  # resolution.
+  #
+  # @param options [Hash] A hash of options to set on the resolution
+  #
+  # @return [Facter::Util::Resolution]
+  #
+  # @api private
+  def add(options = {}, &block)
+    define_resolution(nil, options, &block)
+  end
 
-      resolve.instance_eval(&block) if block
-      @resolves << resolve
+  # Define a new named resolution or return an existing resolution with
+  # the given name.
+  #
+  # @param resolution_name [String] The name of the resolve to define or look up
+  # @param options [Hash] A hash of options to set on the resolution
+  # @return [Facter::Util::Resolution]
+  #
+  # @api public
+  def define_resolution(resolution_name, options = {}, &block)
 
-      resolve
-    rescue => e
-      Facter.warn "Unable to add resolve for #{@name}: #{e}"
-      nil
-    end
+    resolution_type = options.delete(:type) || :simple
+
+    resolve = create_or_return_resolution(resolution_name, resolution_type)
+
+    resolve.set_options(options) unless options.empty?
+    resolve.evaluate(&block) if block
+
+    resolve
+  rescue => e
+    Facter.log_exception(e, "Unable to add resolve #{resolution_name.inspect} for fact #{@name}: #{e.message}")
   end
 
-  ##
-  # Flush any cached values.  If the resolver has a callback block defined
-  # using the on_flush DSL method, then invoke that block by sending a message
-  # to Resolution#flush.
+  # Retrieve an existing resolution by name
+  #
+  # @param name [String]
+  #
+  # @return [Facter::Util::Resolution, nil] The resolution if exists, nil if
+  #   it doesn't exist or name is nil
+  def resolution(name)
+    return nil if name.nil?
+
+    @resolves.find { |resolve| resolve.name == name }
+  end
+
+  # Flushes any cached values.
+  #
+  # @return [void]
+  #
+  # @api private
   def flush
     @resolves.each { |r| r.flush }
     @value = nil
   end
 
-  # Return the value for a given fact.  Searches through all of the mechanisms
-  # and returns either the first value or nil.
+  # Returns the value for this fact. This searches all resolutions by
+  # suitability and weight (see {Facter::Util::Resolution}). If no
+  # suitable resolution is found, it returns nil.
+  #
+  # @api public
   def value
     return @value if @value
 
@@ -75,6 +119,14 @@ class Facter::Util::Fact
     end
   end
 
+  # @api private
+  # @deprecated
+  def extract_ldapname_option!(options)
+    if options[:ldapname]
+      Facter.warnonce("ldapname is deprecated and will be removed in a future version")
+      self.ldapname = options.delete(:ldapname)
+    end
+  end
 
   private
 
@@ -106,7 +158,7 @@ class Facter::Util::Fact
 
   def find_first_real_value(resolutions)
     resolutions.each do |resolve|
-      value = normalize_value(resolve.value)
+      value = resolve.value
       if not value.nil?
         return value
       end
@@ -126,7 +178,27 @@ class Facter::Util::Fact
     end
   end
 
-  def normalize_value(value)
-    value == "" ? nil : value
+  def create_or_return_resolution(resolution_name, resolution_type)
+    resolve = self.resolution(resolution_name)
+
+    if resolve
+      if resolution_type != resolve.resolution_type
+        raise ArgumentError, "Cannot return resolution #{resolution_name} with type" +
+          " #{resolution_type}; already defined as #{resolve.resolution_type}"
+      end
+    else
+      case resolution_type
+      when :simple
+        resolve = Facter::Util::Resolution.new(resolution_name, self)
+      when :aggregate
+        resolve = Facter::Core::Aggregate.new(resolution_name, self)
+      else
+        raise ArgumentError, "Expected resolution type to be one of (:simple, :aggregate) but was #{resolution_type}"
+      end
+
+      @resolves << resolve
+    end
+
+    resolve
   end
 end

data/lib/facter/util/file_read.rb

@@ -1,26 +1,27 @@
 module Facter
 module Util
-##
+
 # {Facter::Util::FileRead} is a utility module intended to provide easily
 # mockable methods that delegate to simple file read methods.  The intent is to
 # avoid the need to execute the `cat` system command or `File.read` directly in
 # Ruby, as mocking these behaviors can have wide-ranging effects.
 #
 # All Facter facts are encouraged to use this method instead of File.read or
-# Facter::Util::Resolution.exec('cat ...')
+# Facter::Core::Execution.exec('cat ...')
 #
 # @api public
 module FileRead
-  ##
   # read returns the raw content of a file as a string.  If the file does not
   # exist, or the process does not have permission to read the file then nil is
   # returned.
   #
   # @api public
   #
-  # @return [String] the raw contents of the file at {path} or {nil} if the
-  # file cannot be read because it does not exist or the process does not have
-  # permission to read the file.
+  # @param path [String] the path to be read
+  #
+  # @return [String, nil] the raw contents of the file or `nil` if the
+  #   file cannot be read because it does not exist or the process does not have
+  #   permission to read the file.
   def self.read(path)
     File.read(path)
   rescue Errno::ENOENT, Errno::EACCES => detail

data/lib/facter/util/formatter.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+
+module Facter
+  module Util
+    module Formatter
+
+      def self.format_json(hash)
+        if Facter.json?
+          JSON.pretty_generate(hash)
+        else
+          raise "Cannot format facts as JSON; 'json' library is not present"
+        end
+      end
+
+      def self.format_yaml(hash)
+        YAML.dump(hash)
+      end
+
+      def self.format_plaintext(hash)
+        output = ''
+
+        # Print the value of a single fact, otherwise print a list sorted by fact
+        # name and separated by "=>"
+        if hash.length == 1
+          if value = hash.values.first
+            output = value
+          end
+        else
+          hash.sort_by { |(name, value)| name }.each do |name,value|
+            output << "#{name} => #{value}\n"
+          end
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/facter/util/ip.rb

@@ -96,7 +96,7 @@ module Facter::Util::IP
   #
   # @return [String] the output of `ifconfig #{arguments} 2>/dev/null` or nil
   def self.exec_ifconfig(additional_arguments=[])
-    Facter::Util::Resolution.exec("#{self.get_ifconfig} #{additional_arguments.join(' ')}")
+    Facter::Core::Execution.exec("#{self.get_ifconfig} #{additional_arguments.join(' ')}")
   end
   ##
   # get_ifconfig looks up the ifconfig binary
@@ -110,7 +110,7 @@ module Facter::Util::IP
   # hpux_netstat_in is a delegate method that allows us to stub netstat -in
   # without stubbing exec.
   def self.hpux_netstat_in
-    Facter::Util::Resolution.exec("/bin/netstat -in")
+    Facter::Core::Execution.exec("/bin/netstat -in")
   end
 
   def self.get_infiniband_macaddress(interface)
@@ -160,7 +160,7 @@ module Facter::Util::IP
   end
 
   def self.hpux_lanscan
-    Facter::Util::Resolution.exec("/usr/sbin/lanscan")
+    Facter::Core::Execution.exec("/usr/sbin/lanscan")
   end
 
   def self.get_output_for_interface_and_label(interface, label)

data/lib/facter/util/loader.rb

@@ -5,45 +5,48 @@ require 'facter/util/directory_loader'
 # Load facts on demand.
 class Facter::Util::Loader
 
-  def initialize
+  def initialize(environment_vars = ENV)
     @loaded = []
-    @valid_path = {}
+    @environment_vars = environment_vars
   end
 
   # Load all resolutions for a single fact.
+  #
+  # @api public
+  # @param name [Symbol]
   def load(fact)
     # Now load from the search path
     shortname = fact.to_s.downcase
     load_env(shortname)
 
     filename = shortname + ".rb"
-    search_path.each do |dir|
-      # Load individual files
-      file = File.join(dir, filename)
 
-      load_file(file) if FileTest.exist?(file)
+    paths = search_path
+    unless paths.nil?
+      paths.each do |dir|
+        # Load individual files
+        file = File.join(dir, filename)
 
-      # And load any directories matching the name
-      factdir = File.join(dir, shortname)
-      load_dir(factdir) if FileTest.directory?(factdir)
+        load_file(file) if File.file?(file)
+      end
     end
   end
 
   # Load all facts from all directories.
+  #
+  # @api public
   def load_all
     return if defined?(@loaded_all)
 
     load_env
 
-    search_path.each do |dir|
-      next unless FileTest.directory?(dir)
-
-      Dir.entries(dir).sort.each do |file|
-        path = File.join(dir, file)
-        if File.directory?(path)
-          load_dir(path)
-        elsif file =~ /\.rb$/
-          load_file(File.join(dir, file))
+    paths = search_path
+    unless paths.nil?
+      paths.each do |dir|
+        # dir is already an absolute path
+        Dir.glob(File.join(dir, '*.rb')).each do |path|
+          # exclude dirs that end with .rb
+          load_file(path) if File.file?(path)
         end
       end
     end
@@ -51,43 +54,60 @@ class Facter::Util::Loader
     @loaded_all = true
   end
 
-  # The list of directories we're going to search through for facts.
+  # List directories to search for fact files.
+  #
+  # Search paths are gathered from the following sources:
+  #
+  # 1. $LOAD_PATH entries are expanded to absolute paths
+  # 2. ENV['FACTERLIB'] is split and used verbatim
+  # 3. Entries from Facter.search_path are used verbatim
+  #
+  # A warning will be generated for paths in Facter.search_path that are not
+  # absolute directories.
+  #
+  # @api public
+  # @return [Array<String>]
   def search_path
-    result = []
-    result += $LOAD_PATH.collect { |d| File.join(d, "facter") }
-    if ENV.include?("FACTERLIB")
-      result += ENV["FACTERLIB"].split(File::PATH_SEPARATOR)
+    search_paths = []
+    search_paths += $LOAD_PATH.map { |path| File.expand_path('facter', path) }
+
+    if @environment_vars.include?("FACTERLIB")
+      search_paths += @environment_vars["FACTERLIB"].split(File::PATH_SEPARATOR)
     end
 
-    # This allows others to register additional paths we should search.
-    result += Facter.search_path
+    search_paths.delete_if { |path| ! valid_search_path?(path) }
 
-    result.select do |dir|
-      good = valid_search_path? dir
-      Facter.debugonce("Relative directory #{dir} removed from search path.") unless good
-      good
+    Facter.search_path.each do |path|
+      if valid_search_path?(path)
+        search_paths << path
+      else
+        Facter.warn "Excluding #{path} from search path. Fact file paths must be an absolute directory"
+      end
     end
-  end
 
-  def valid_search_path?(path)
-    return @valid_path[path] unless @valid_path[path].nil?
+    search_paths.delete_if { |path| ! File.directory?(path) }
 
-    return @valid_path[path] = Pathname.new(path).absolute?
+    search_paths.uniq
   end
-  private :valid_search_path?
 
   private
 
-  def load_dir(dir)
-    return if dir =~ /\/\.+$/ or dir =~ /\/util$/ or dir =~ /\/lib$/
-
-    Dir.entries(dir).find_all { |f| f =~ /\.rb$/ }.sort.each do |file|
-      load_file(File.join(dir, file))
-    end
+  # Validate that the given path is valid, ie it is an absolute path.
+  #
+  # @api private
+  # @param path [String]
+  # @return [Boolean]
+  def valid_search_path?(path)
+    Pathname.new(path).absolute?
   end
 
+  # Load a file and record is paths to prevent duplicate loads.
+  #
+  # @api private
+  # @params file [String] The *absolute path* to the file to load
   def load_file(file)
     return if @loaded.include? file
+
     # We have to specify Kernel.load, because we have a load method.
     begin
       # Store the file path so we don't try to reload it
@@ -97,7 +117,7 @@ class Facter::Util::Loader
       # Don't store the path if the file can't be loaded
       # in case it's loadable later on.
       @loaded.delete(file)
-      Facter.warn "Error loading fact #{file} #{detail}"
+      Facter.log_exception(detail, "Error loading fact #{file}: #{detail.message}")
     end
   end
 
@@ -105,7 +125,7 @@ class Facter::Util::Loader
   # all will be loaded.
   def load_env(fact = nil)
     # Load from the environment, if possible
-    ENV.each do |name, value|
+    @environment_vars.each do |name, value|
       # Skip anything that doesn't match our regex.
       next unless name =~ /^facter_?(\w+)$/i
       env_name = $1