facter 1.6.18 → 1.7.0.rc1

data/lib/facter/util/composite_loader.rb

@@ -0,0 +1,12 @@
+# A composite loader that allows for more than one
+# default directory loader
+
+class Facter::Util::CompositeLoader
+  def initialize(loaders)
+    @loaders = loaders
+  end
+
+  def load(collection)
+    @loaders.each { |loader| loader.load(collection) }
+  end
+end

data/lib/facter/util/config.rb

@@ -3,7 +3,43 @@ require 'rbconfig'
 # A module to return config related data
 #
 module Facter::Util::Config
+
+  def self.ext_fact_loader
+    @ext_fact_loader || Facter::Util::DirectoryLoader.default_loader
+  end
+
+  def self.ext_fact_loader=(loader)
+    @ext_fact_loader = loader
+  end
+
+  def self.is_mac?
+    RbConfig::CONFIG['host_os'] =~ /darwin/i
+  end
+
+  # Returns true if OS is windows
   def self.is_windows?
     RbConfig::CONFIG['host_os'] =~ /mswin|win32|dos|mingw|cygwin/i
   end
+
+  def self.windows_data_dir
+    if Dir.const_defined? 'COMMON_APPDATA' then
+      Dir::COMMON_APPDATA
+    else
+      nil
+    end
+  end
+
+  def self.external_facts_dirs
+    windows_dir = windows_data_dir
+    if windows_dir.nil? then
+      ["/etc/facter/facts.d", "/etc/puppetlabs/facter/facts.d"]
+    else
+      [File.join(windows_dir, 'PuppetLabs', 'facter', 'facts.d')]
+    end
+  end
+end
+
+if Facter::Util::Config.is_windows?
+  require 'rubygems'
+  require 'win32/dir'
 end

data/lib/facter/util/confine.rb

@@ -31,11 +31,6 @@ class Facter::Util::Confine
 
     return false if value.nil?
 
-    @values.each do |v|
-      v = convert(v)
-      next unless v.class == value.class
-      return true if value == v
-    end
-    return false
+    return @values.any? { |v| convert(v) === value }
   end
 end

data/lib/facter/util/directory_loader.rb

@@ -0,0 +1,83 @@
+# A Facter plugin that loads external facts.
+#
+# Default Unix Directories:
+# /etc/facter/facts.d, /etc/puppetlbas/facter/facts.d
+#
+# Default Windows Direcotires:
+# C:\ProgramData\Puppetlabs\facter\facts.d (2008)
+# C:\Documents and Settings\All Users\Application Data\Puppetlabs\facter\facts.d (2003)
+#
+# Can also load from command-line specified directory
+#
+# Facts can be in the form of JSON, YAML or Text files
+# and any executable that returns key=value pairs.
+
+require 'facter'
+require 'facter/util/config'
+require 'facter/util/composite_loader'
+require 'facter/util/parser'
+require 'yaml'
+
+class Facter::Util::DirectoryLoader
+
+  class NoSuchDirectoryError < Exception
+  end
+
+  # This value makes it highly likely that external facts will take
+  # precedence over all other facts
+  EXTERNAL_FACT_WEIGHT = 10000
+
+  # Directory for fact loading
+  attr_reader :directory
+
+  def initialize(dir)
+    @directory = dir
+  end
+
+  def self.loader_for(dir)
+    if File.directory?(dir)
+      Facter::Util::DirectoryLoader.new(dir)
+    else
+      raise NoSuchDirectoryError
+    end
+  end
+
+  def self.default_loader
+    loaders = Facter::Util::Config.external_facts_dirs.collect do |dir|
+      Facter::Util::DirectoryLoader.new(dir)
+    end
+    Facter::Util::CompositeLoader.new(loaders)
+  end
+
+  # Load facts from files in fact directory using the relevant parser classes to
+  # parse them.
+  def load(collection)
+    entries.each do |file|
+      parser = Facter::Util::Parser.parser_for(file)
+      if parser == nil
+        next
+      end
+
+      data = parser.results
+      if data == false
+        Facter.warn "Could not interpret fact file #{file}"
+      elsif data == {} or data == nil
+        Facter.warn "Fact file #{file} was parsed but returned an empty data set"
+      else
+        data.each { |p,v| collection.add(p, :value => v) { has_weight(EXTERNAL_FACT_WEIGHT) } }
+      end
+    end
+  end
+
+private
+
+  def entries
+    Dir.entries(directory).find_all { |f| should_parse?(f) }.sort.map { |f| File.join(directory, f) }
+  rescue Errno::ENOENT => detail
+    []
+  end
+
+  def should_parse?(file)
+    not file =~ /^\./
+  end
+end

data/lib/facter/util/fact.rb

@@ -30,20 +30,13 @@ class Facter::Util::Fact
 
   # Add a new resolution mechanism.  This requires a block, which will then
   # be evaluated in the context of the new mechanism.
-  def add(&block)
-    raise ArgumentError, "You must pass a block to Fact<instance>.add" unless block_given?
-
+  def add(value = nil, &block)
     begin
       resolve = Facter::Util::Resolution.new(@name)
 
-      resolve.instance_eval(&block)
-
+      resolve.instance_eval(&block) if block
       @resolves << resolve
 
-      # Immediately sort the resolutions, so that we always have
-      # a sorted list for looking up values.
-      @resolves.sort! { |a, b| b.weight <=> a.weight }
-
       resolve
     rescue => e
       Facter.warn "Unable to add resolve for #{@name}: #{e}"
@@ -51,10 +44,13 @@ class Facter::Util::Fact
     end
   end
 
-  # Flush any cached values.
+  ##
+  # 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.
   def flush
+    @resolves.each { |r| r.flush }
     @value = nil
-    @suitable = nil
   end
 
   # Return the value for a given fact.  Searches through all of the mechanisms
@@ -62,38 +58,24 @@ class Facter::Util::Fact
   def value
     return @value if @value
 
-    if @resolves.length == 0
+    if @resolves.empty?
       Facter.debug "No resolves for %s" % @name
       return nil
     end
 
     searching do
-      @value = nil
-
-      foundsuits = false
-      @value = @resolves.inject(nil) { |result, resolve|
-        next unless resolve.suitable?
-        foundsuits = true
 
-        tmp = resolve.value
+      suitable_resolutions = sort_by_weight(find_suitable_resolutions(@resolves))
+      @value = find_first_real_value(suitable_resolutions)
 
-        break tmp unless tmp.nil? or tmp == ""
-      }
+      announce_when_no_suitable_resolution(suitable_resolutions)
+      announce_when_no_value_found(@value)
 
-      unless foundsuits
-        Facter.debug "Found no suitable resolves of %s for %s" % [@resolves.length, @name]
-      end
-    end
-
-    if @value.nil?
-      # nothing
-      Facter.debug("value for %s is still nil" % @name)
-      return nil
-    else
-      return @value
+      @value
     end
   end
 
+
   private
 
   # Are we in the midst of a search?
@@ -103,16 +85,7 @@ class Facter::Util::Fact
 
   # Lock our searching process, so we never ge stuck in recursion.
   def searching
-    if searching?
-      Facter.debug "Caught recursion on %s" % @name
-
-      # return a cached value if we've got it
-      if @value
-        return @value
-      else
-        return nil
-      end
-    end
+    raise RuntimeError, "Caught recursion on #{@name}" if searching?
 
     # If we've gotten this far, we're not already searching, so go ahead and do so.
     @searching = true
@@ -122,4 +95,38 @@ class Facter::Util::Fact
       @searching = false
     end
   end
+
+  def find_suitable_resolutions(resolutions)
+    resolutions.find_all{ |resolve| resolve.suitable? }
+  end
+
+  def sort_by_weight(resolutions)
+    resolutions.sort { |a, b| b.weight <=> a.weight }
+  end
+
+  def find_first_real_value(resolutions)
+    resolutions.each do |resolve|
+      value = normalize_value(resolve.value)
+      if not value.nil?
+        return value
+      end
+    end
+    nil
+  end
+
+  def announce_when_no_suitable_resolution(resolutions)
+    if resolutions.empty?
+      Facter.debug "Found no suitable resolves of %s for %s" % [@resolves.length, @name]
+    end
+  end
+
+  def announce_when_no_value_found(value)
+    if value.nil?
+      Facter.debug("value for %s is still nil" % @name)
+    end
+  end
+
+  def normalize_value(value)
+    value == "" ? nil : value
+  end
 end

data/lib/facter/util/file_read.rb

@@ -0,0 +1,32 @@
+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 ...')
+#
+# @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.
+  def self.read(path)
+    File.read(path)
+  rescue Errno::ENOENT, Errno::EACCES => detail
+    Facter.debug "Could not read #{path}: #{detail.message}"
+    nil
+  end
+end
+end
+end

data/lib/facter/util/ip.rb

@@ -5,8 +5,8 @@ module Facter::Util::IP
   # a given platform or set of platforms.
   REGEX_MAP = {
     :linux => {
-      :ipaddress  => /inet addr:([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
-      :ipaddress6 => /inet6 addr: ((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
+      :ipaddress  => /inet (?:addr:)?([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
+      :ipaddress6 => /inet6 (?:addr: )?((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
       :macaddress => /(?:ether|HWaddr)\s+((\w{1,2}:){5,}\w{1,2})/,
       :netmask  => /Mask:([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
       :mtu  => /MTU:(\d+)/
@@ -286,11 +286,4 @@ module Facter::Util::IP
       network = ip.mask(subnet.to_s).to_s
     end
   end
-
-  def self.get_arp_value(interface)
-    arp = Facter::Util::Resolution.exec("arp -en -i #{interface} | sed -e 1d")
-    if arp =~ /^\S+\s+\w+\s+(\S+)\s+\w\s+\S+$/
-     return $1
-    end
-  end
 end

data/lib/facter/util/loader.rb

@@ -1,10 +1,13 @@
 require 'facter'
+require 'pathname'
+require 'facter/util/directory_loader'
 
 # Load facts on demand.
 class Facter::Util::Loader
 
   def initialize
     @loaded = []
+    @valid_path = {}
   end
 
   # Load all resolutions for a single fact.
@@ -53,14 +56,25 @@ class Facter::Util::Loader
     result = []
     result += $LOAD_PATH.collect { |d| File.join(d, "facter") }
     if ENV.include?("FACTERLIB")
-      result += ENV["FACTERLIB"].split(":")
+      result += ENV["FACTERLIB"].split(File::PATH_SEPARATOR)
     end
 
     # This allows others to register additional paths we should search.
     result += Facter.search_path
 
-    result
+    result.select do |dir|
+      good = valid_search_path? dir
+      Facter.debugonce("Relative directory #{dir} removed from search path.") unless good
+      good
+    end
+  end
+
+  def valid_search_path?(path)
+    return @valid_path[path] unless @valid_path[path].nil?
+
+    return @valid_path[path] = Pathname.new(path).absolute?
   end
+  private :valid_search_path?
 
   private
 

data/lib/facter/util/macosx.rb

@@ -7,9 +7,11 @@
 
 module Facter::Util::Macosx
   require 'thread'
-  require 'facter/util/plist'
+  require 'facter/util/cfpropertylist'
   require 'facter/util/resolution'
 
+  Plist_Xml_Doctype  = '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
+
   # JJM I'd really like to dynamically generate these methods
   # by looking at the _name key of the _items dict for each _dataType
 
@@ -19,7 +21,18 @@ module Facter::Util::Macosx
 
   def self.intern_xml(xml)
     return nil unless xml
-    Plist::parse_xml(xml)
+    bad_xml_doctype = /^.*<!DOCTYPE plist PUBLIC -\/\/Apple Computer.*$/
+    if xml =~ bad_xml_doctype
+      xml.gsub!( bad_xml_doctype, Plist_Xml_Doctype )
+      Facter.debug("Had to fix plist with incorrect DOCTYPE declaration")
+    end
+    plist = Facter::Util::CFPropertyList::List.new
+    begin
+      plist.load_str(xml)
+    rescue => e
+      fail("A plist file could not be properly read by Facter::Util::CFPropertyList: #{e.inspect}")
+    end
+    Facter::Util::CFPropertyList.native_types(plist.value)
   end
 
   # Return an xml result, modified as we need it.

data/lib/facter/util/memory.rb

@@ -3,25 +3,17 @@
 ##
 
 module Facter::Memory
-  require 'thread'
-
   def self.meminfo_number(tag)
     memsize = ""
-    Thread::exclusive do
-      size, scale = [0, ""]
-      File.readlines("/proc/meminfo").each do |l|
-        size, scale = [$1.to_f, $2] if l =~ /^#{tag}:\s+(\d+)\s+(\S+)/
-        # MemoryFree == memfree + cached + buffers
-        #  (assume scales are all the same as memfree)
-        if tag == "MemFree" &&
-          l =~ /^(?:Buffers|Cached):\s+(\d+)\s+(?:\S+)/
-          size += $1.to_f
-        end
+    size = [0]
+    File.readlines("/proc/meminfo").each do |l|
+      size = $1.to_f if l =~ /^#{tag}:\s+(\d+)\s+\S+/
+      if tag == "MemFree" &&
+          l =~ /^(?:Buffers|Cached):\s+(\d+)\s+\S+/
+        size += $1.to_f
       end
-      memsize = scale_number(size, scale)
     end
-
-    memsize
+    size / 1024.0
   end
 
   def self.scale_number(size, multiplier)
@@ -37,18 +29,15 @@ module Facter::Memory
       s = suffixes.shift
     end
 
-    return "%.2f %s" % [size, s]
+    "%.2f %s" % [size, s]
   end
 
-  def self.vmstat_find_free_memory()
-    row = Facter::Util::Resolution.exec('vmstat').split("\n")[-1]
+  def self.vmstat_find_free_memory(args = [])
+    cmd = 'vmstat'
+    cmd += (' ' + args.join(' ')) unless args.empty?
+    row = Facter::Util::Resolution.exec(cmd).split("\n")[-1]
     if row =~ /^\s*\d+\s*\d+\s*\d+\s*\d+\s*(\d+)/
-      Facter.add("MemoryFree") do
-        memfree = $1
-        setcode do
-          Facter::Memory.scale_number(memfree.to_f, "kB")
-        end
-      end
+      memfree = $1
     end
   end
 
@@ -76,10 +65,148 @@ module Facter::Memory
     end
 
     freemem = ( memfree + memspecfree ) * pagesize
-    Facter.add("MemoryFree") do
-      setcode do
-        Facter::Memory.scale_number(freemem.to_f, "")
+  end
+
+  def self.mem_free(kernel = Facter.value(:kernel))
+    output = mem_free_info(kernel)
+    scale_mem_free_value output, kernel
+  end
+
+  def self.mem_free_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /OpenBSD/i, /SunOS/i, /Dragonfly/i
+      vmstat_find_free_memory()
+    when /FreeBSD/i
+      vmstat_find_free_memory(["-H"])
+    when /Darwin/i
+      vmstat_darwin_find_free_memory()
+    end
+  end
+
+  def self.scale_mem_free_value (value, kernel)
+    case kernel
+    when /OpenBSD/i, /FreeBSD/i, /SunOS/i, /Dragonfly/i
+      value.to_f / 1024.0
+    when /Darwin/i
+      value.to_f / 1024.0 / 1024.0
+    else
+      value.to_f
+    end
+ end
+
+  def self.mem_size(kernel = Facter.value(:kernel))
+    output = mem_size_info(kernel)
+    scale_mem_size_value output, kernel
+  end
+
+  def self.mem_size_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /OpenBSD/i
+      Facter::Util::Resolution.exec("sysctl hw.physmem | cut -d'=' -f2")
+    when /FreeBSD/i
+      Facter::Util::Resolution.exec("sysctl -n hw.physmem")
+    when /Darwin/i
+      Facter::Util::Resolution.exec("sysctl -n hw.memsize")
+    when /Dragonfly/i
+      Facter::Util::Resolution.exec("sysctl -n hw.physmem")
+    end
+  end
+
+  def self.scale_mem_size_value(value, kernel)
+    case kernel
+    when /OpenBSD/i, /FreeBSD/i, /Darwin/i, /Dragonfly/i
+      value.to_f / 1024.0 / 1024.0
+    else
+      value.to_f
+    end
+  end
+
+  def self.swap_size(kernel = Facter.value(:kernel))
+    output = swap_info(kernel)
+    parse_swap output, kernel, :size if output
+  end
+
+  def self.swap_free(kernel = Facter.value(:kernel))
+    output = swap_info(kernel)
+    parse_swap output, kernel, :free if output
+  end
+
+  def self.swap_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /AIX/i
+      (Facter.value(:id) == "root") ? Facter::Util::Resolution.exec('swap -l') : nil
+    when /OpenBSD/i
+      Facter::Util::Resolution.exec('swapctl -s')
+    when /FreeBSD/i
+      Facter::Util::Resolution.exec('swapinfo -k')
+    when /Darwin/i
+      Facter::Util::Resolution.exec('sysctl vm.swapusage')
+    when /SunOS/i
+      Facter::Util::Resolution.exec('/usr/sbin/swap -l')
+    end
+  end
+
+  def self.parse_swap (output, kernel = Facter.value(:kernel), size_or_free = :size)
+    value_in_mb = 0.0
+    value = 0
+    is_size = size_or_free == :size
+    unless output.nil?
+      output.each_line do |line|
+        value += parse_swap_line(line, kernel, is_size)
+      end
+    end      
+    value_in_mb = scale_swap_value(value, kernel)
+  end
+
+  # There is a lot of duplication here because of concern over being able to add
+  # new platforms in a reasonable manner. For all of these platforms the first
+  # regex corresponds to the swap size value and the second corresponds to the swap
+  # free value, but this may not always be the case. In Ruby 1.9.3 it is possible
+  # to give these names, but sadly 1.8.7 does not support this.
+ 
+  def self.parse_swap_line(line, kernel, is_size)
+    case kernel
+    when /AIX/i
+      if line =~ /^\/\S+\s.*\s+(\S+)MB\s+(\S+)MB/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /OpenBSD/i
+      if line =~ /^total: (\d+)k bytes allocated = \d+k used, (\d+)k available$/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /FreeBSD/i
+      if line =~ /\S+\s+(\d+)\s+\d+\s+(\d+)\s+\d+%$/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /Darwin/i
+      if line =~ /total\s=\s(\S+)M\s+used\s=\s\S+M\s+free\s=\s(\S+)M\s/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
       end
+    when /SunOS/i
+      if line =~ /^\/\S+\s.*\s+(\d+)\s+(\d+)$/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    end
+  end
+
+  def self.scale_swap_value(value, kernel)
+    case kernel
+    when /OpenBSD/i, /FreeBSD/i
+      value.to_f / 1024.0
+    when /SunOS/i
+      value.to_f / 2 / 1024.0
+    else
+      value.to_f
     end
   end
 end