facter 2.0.1.rc1-universal-darwin

data/lib/facter/core/resolvable.rb

@@ -0,0 +1,94 @@
+require 'timeout'
+
+# The resolvable mixin defines behavior for evaluating and returning fact
+# resolutions.
+#
+# Classes including this mixin should implement at #name method describing
+# the value being resolved and a #resolve_value that actually executes the code
+# to resolve the value.
+module Facter::Core::Resolvable
+
+  # The timeout, in seconds, for evaluating this resolution.
+  # @return [Integer]
+  # @api public
+  attr_accessor :timeout
+
+  # Return the timeout period for resolving a value.
+  # (see #timeout)
+  # @return [Numeric]
+  # @comment requiring 'timeout' stdlib class causes Object#timeout to be
+  #   defined which delegates to Timeout.timeout. This method may potentially
+  #   overwrite the #timeout attr_reader on this class, so we define #limit to
+  #   avoid conflicts.
+  def limit
+    @timeout || 0
+  end
+
+  ##
+  # on_flush accepts a block and executes the block when the resolution's value
+  # is flushed.  This makes it possible to model a single, expensive system
+  # call inside of a Ruby object and then define multiple dynamic facts which
+  # resolve by sending messages to the model instance.  If one of the dynamic
+  # facts is flushed then it can, in turn, flush the data stored in the model
+  # instance to keep all of the dynamic facts in sync without making multiple,
+  # expensive, system calls.
+  #
+  # Please see the Solaris zones fact for an example of how this feature may be
+  # used.
+  #
+  # @see Facter::Util::Fact#flush
+  # @see Facter::Util::Resolution#flush
+  #
+  # @api public
+  def on_flush(&block)
+    @on_flush_block = block
+  end
+
+  ##
+  # flush executes the block, if any, stored by the {on_flush} method
+  #
+  # @see Facter::Util::Fact#flush
+  # @see Facter::Util::Resolution#on_flush
+  #
+  # @api private
+  def flush
+    @on_flush_block.call if @on_flush_block
+  end
+
+  def value
+    result = nil
+
+    with_timing do
+      Timeout.timeout(limit) do
+        result = resolve_value
+      end
+    end
+
+    Facter::Util::Normalization.normalize(result)
+  rescue Timeout::Error => detail
+    Facter.log_exception(detail, "Timed out after #{limit} seconds while resolving #{qualified_name}")
+    return nil
+  rescue Facter::Util::Normalization::NormalizationError => detail
+    Facter.log_exception(detail, "Fact resolution #{qualified_name} resolved to an invalid value: #{detail.message}")
+    return nil
+  rescue => detail
+    Facter.log_exception(detail, "Could not retrieve #{qualified_name}: #{detail.message}")
+    return nil
+  end
+
+  private
+
+  def with_timing
+    starttime = Time.now.to_f
+
+    yield
+
+    finishtime = Time.now.to_f
+    ms = (finishtime - starttime) * 1000
+    Facter.show_time "#{qualified_name}: #{"%.2f" % ms}ms"
+  end
+
+  def qualified_name
+    "fact='#{@fact.name.to_s}', resolution='#{@name || '<anonymous>'}'"
+  end
+end

data/lib/facter/core/suitable.rb

@@ -0,0 +1,117 @@
+require 'facter'
+
+# The Suitable mixin provides mechanisms for confining objects to run on
+# certain platforms and determining the run precedence of these objects.
+#
+# Classes that include the Suitable mixin should define a `#confines` method
+# that returns an Array of zero or more Facter::Util::Confine objects.
+module Facter::Core::Suitable
+
+  attr_writer :weight
+
+  # Sets the weight of this resolution. If multiple suitable resolutions
+  # are found, the one with the highest weight will be used.  If weight
+  # is not given, the number of confines set on a resolution will be
+  # used as its weight (so that the most specific resolution is used).
+  #
+  # @param weight [Integer] the weight of this resolution
+  #
+  # @return [void]
+  #
+  # @api public
+  def has_weight(weight)
+    @weight = weight
+  end
+
+  # Sets the conditions for this resolution to be used.  This method accepts
+  # multiple forms of arguments to determine suitability.
+  #
+  # @return [void]
+  #
+  # @api public
+  #
+  # @overload confine(confines)
+  #   Confine a fact to a specific fact value or values.  This form takes a
+  #   hash of fact names and values. Every fact must match the values given for
+  #   that fact, otherwise this resolution will not be considered suitable. The
+  #   values given for a fact can be an array, in which case the value of the
+  #   fact must be in the array for it to match.
+  #   @param [Hash{String,Symbol=>String,Array<String>}] confines set of facts identified by the hash keys whose
+  #     fact value must match the argument value.
+  #   @example Confining to Linux
+  #       Facter.add(:powerstates) do
+  #         # This resolution only makes sense on linux systems
+  #         confine :kernel => "Linux"
+  #         setcode do
+  #           File.read('/sys/power/states')
+  #         end
+  #       end
+  #
+  # @overload confine(confines, &block)
+  #   Confine a fact to a block with the value of a specified fact yielded to
+  #   the block.
+  #   @param [String,Symbol] confines the fact name whose value should be
+  #     yielded to the block
+  #   @param [Proc] block determines the suitability of the fact.  If the block
+  #     evaluates to `false` or `nil` then the confined fact will not be
+  #     evaluated.
+  #   @yield [value] the value of the fact identified by {confines}
+  #   @example Confine the fact to a host with an ipaddress in a specific
+  #     subnet
+  #       confine :ipaddress do |addr|
+  #         require 'ipaddr'
+  #         IPAddr.new('192.168.0.0/16').include? addr
+  #       end
+  #
+  # @overload confine(&block)
+  #   Confine a fact to a block.  The fact will be evaluated only if the block
+  #   evaluates to something other than `false` or `nil`.
+  #   @param [Proc] block determines the suitability of the fact.  If the block
+  #     evaluates to `false` or `nil` then the confined fact will not be
+  #     evaluated.
+  #   @example Confine the fact to systems with a specific file.
+  #       confine { File.exist? '/bin/foo' }
+  def confine(confines = nil, &block)
+    case confines
+    when Hash
+      confines.each do |fact, values|
+        @confines.push Facter::Util::Confine.new(fact, *values)
+      end
+    else
+      if block
+        if confines
+          @confines.push Facter::Util::Confine.new(confines, &block)
+        else
+          @confines.push Facter::Util::Confine.new(&block)
+        end
+      else
+      end
+    end
+  end
+
+  # Returns the importance of this resolution. If the weight was not
+  # given, the number of confines is used instead (so that a more
+  # specific resolution wins over a less specific one).
+  #
+  # @return [Integer] the weight of this resolution
+  #
+  # @api private
+  def weight
+    if @weight
+      @weight
+    else
+      @confines.length
+    end
+  end
+
+  # Is this resolution mechanism suitable on the system in question?
+  #
+  # @api private
+  def suitable?
+    unless defined? @suitable
+      @suitable = ! @confines.detect { |confine| ! confine.true? }
+    end
+
+    return @suitable
+  end
+end

data/lib/facter/domain.rb

@@ -0,0 +1,99 @@
+# Fact: domain
+#
+# Purpose:
+#   Return the host's primary DNS domain name.
+#
+# Resolution:
+#   On UNIX (excluding Darwin), first try and use the hostname fact,
+#   which uses the hostname system command, and then parse the output
+#   of that.
+#   Failing that it tries the dnsdomainname system command.
+#   Failing that it uses /etc/resolv.conf and takes the domain from that, or as
+#   a final resort, the search from that.
+#   Otherwise returns nil.
+#
+#   On Windows uses the win32ole gem and winmgmts to get the DNSDomain value
+#   from the Win32 networking stack.
+#
+# Caveats:
+#
+
+Facter.add(:domain) do
+  setcode do
+    # Get the domain from various sources; the order of these
+    # steps is important
+
+    # In some OS 'hostname -f' will change the hostname to '-f'
+    # We know that Solaris and HP-UX exhibit this behavior
+    # On good OS, 'hostname -f' will return the FQDN which is preferable
+    # Due to dangerous behavior of 'hostname -f' on old OS, we will explicitly opt-in
+    # 'hostname -f' --hkenney May 9, 2012
+    basic_hostname = 'hostname 2> /dev/null'
+    windows_hostname = 'hostname > NUL'
+    full_hostname = 'hostname -f 2> /dev/null'
+    can_do_hostname_f = Regexp.union /Linux/i, /FreeBSD/i, /Darwin/i
+
+    hostname_command = if Facter.value(:kernel) =~ can_do_hostname_f
+                         full_hostname
+                       elsif Facter.value(:kernel) == "windows"
+                         windows_hostname
+                       else
+                         basic_hostname
+                       end
+
+    if name = Facter::Core::Execution.exec(hostname_command) \
+      and name =~ /.*?\.(.+$)/
+
+      return_value = $1
+    elsif Facter.value(:kernel) != "windows" and domain = Facter::Core::Execution.exec('dnsdomainname 2> /dev/null') \
+      and domain =~ /.+/
+
+      return_value = domain
+    elsif FileTest.exists?("/etc/resolv.conf")
+      domain = nil
+      search = nil
+      File.open("/etc/resolv.conf") { |file|
+        file.each { |line|
+          if line =~ /^\s*domain\s+(\S+)/
+            domain = $1
+          elsif line =~ /^\s*search\s+(\S+)/
+            search = $1
+          end
+        }
+      }
+      return_value ||= domain
+      return_value ||= search
+    end
+
+    if return_value
+      return_value.gsub(/\.$/, '')
+    end
+  end
+end
+
+Facter.add(:domain) do
+  confine :kernel => :windows
+  setcode do
+    require 'facter/util/registry'
+
+    domain = nil
+    regvalue = Facter::Util::Registry.hklm_read('SYSTEM\CurrentControlSet\Services\Tcpip\Parameters', 'Domain')
+
+    if regvalue and not regvalue.empty?
+      domain = regvalue
+    else
+      require 'facter/util/wmi'
+      Facter::Util::WMI.execquery("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").each { |nic|
+        if nic.DNSDomain && nic.DNSDomain.length > 0
+          domain = nic.DNSDomain
+          break
+        end
+      }
+    end
+
+
+    if domain
+      domain.gsub(/\.$/, '')
+    end
+  end
+end

data/lib/facter/ec2.rb

@@ -0,0 +1,37 @@
+require 'facter/util/ec2'
+require 'open-uri'
+
+def metadata(id = "")
+  open("http://169.254.169.254/2008-02-01/meta-data/#{id||=''}").read.
+    split("\n").each do |o|
+    key = "#{id}#{o.gsub(/\=.*$/, '/')}"
+    if key[-1..-1] != '/'
+      value = open("http://169.254.169.254/2008-02-01/meta-data/#{key}").read.
+        split("\n")
+      symbol = "ec2_#{key.gsub(/\-|\//, '_')}".to_sym
+      Facter.add(symbol) { setcode { value.join(',') } }
+    else
+      metadata(key)
+    end
+  end
+rescue => details
+  Facter.warn "Could not retrieve ec2 metadata: #{details.message}"
+end
+
+def userdata()
+  Facter.add(:ec2_userdata) do
+    setcode do
+      if userdata = Facter::Util::EC2.userdata
+        userdata.split
+      end
+    end
+  end
+end
+
+if (Facter::Util::EC2.has_euca_mac? || Facter::Util::EC2.has_openstack_mac? ||
+    Facter::Util::EC2.has_ec2_arp?) && Facter::Util::EC2.can_connect?
+  metadata
+  userdata
+else
+  Facter.debug "Not an EC2 host"
+end

data/lib/facter/facterversion.rb

@@ -0,0 +1,15 @@
+# Fact: facterversion
+#
+# Purpose: returns the version of the facter module.
+#
+# Resolution: Uses the Facter.version method.
+#
+# Caveats:
+#
+
+Facter.add(:facterversion) do
+  setcode do
+    require 'facter/version'
+    Facter.version.to_s
+  end
+end

data/lib/facter/filesystems.rb

@@ -0,0 +1,38 @@
+#
+# filesystems.rb
+#
+# This fact provides an alphabetic list of usable file systems that can
+# be used for block devices like hard drives, media cards and so on ...
+#
+Facter.add('filesystems') do
+  confine :kernel => :linux
+  setcode do
+    # fuseblk can't be created and arguably isn't usable here. If you feel this
+    # doesn't match your use-case please raise a bug.
+    exclude = %w(fuseblk)
+
+    # Make regular expression form our patterns ...
+    exclude = Regexp.union(*exclude.collect { |i| Regexp.new(i) })
+
+    # We utilise rely on "cat" for reading values from entries under "/proc".
+    # This is due to some problems with IO#read in Ruby and reading content of
+    # the "proc" file system that was reported more than once in the past ...
+    file_systems = []
+    Facter::Core::Execution.exec('cat /proc/filesystems 2> /dev/null').each_line do |line|
+      # Remove bloat ...
+      line.strip!
+
+      # Line of interest should not start with "nodev" ...
+      next if line.empty? or line.match(/^nodev/)
+
+      # We have something, so let us apply our device type filter ...
+      next if line.match(exclude)
+
+      file_systems << line
+    end
+    file_systems.sort.join(',')
+  end
+end
+
+# vim: set ts=2 sw=2 et :
+# encoding: utf-8

data/lib/facter/fqdn.rb

@@ -0,0 +1,22 @@
+# Fact: fqdn
+#
+# Purpose: Returns the fully qualified domain name of the host.
+#
+# Resolution: Simply joins the hostname fact with the domain name fact.
+#
+# Caveats: No attempt is made to check that the two facts are accurate or that
+# the two facts go together. At no point is there any DNS resolution made
+# either.
+#
+
+Facter.add(:fqdn) do
+  setcode do
+    host = Facter.value(:hostname)
+    domain = Facter.value(:domain)
+    if host and domain
+      [host, domain].join(".")
+    else
+      nil
+    end
+  end
+end

data/lib/facter/hardwareisa.rb

@@ -0,0 +1,20 @@
+# Fact: hardwareisa
+#
+# Purpose:
+#   Returns hardware processor type.
+#
+# Resolution:
+#   On Solaris, AIX, Linux and the BSDs simply uses the output of "uname -p"
+#   On HP-UX, "uname -m" gives us the same information.
+#
+# Caveats:
+#   Some linuxes return unknown to uname -p with relative ease.
+#
+
+Facter.add(:hardwareisa) do
+  if Facter.value(:kernel) == 'HP-UX'
+    setcode 'uname -m'
+  else
+    setcode 'uname -p'
+  end
+end