facter 2.1.0-x64-mingw32

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,113 @@
+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?
+    @confines.all? { |confine| confine.true? }
+  end
+end

data/lib/facter/dhcp_servers.rb

@@ -0,0 +1,39 @@
+# Fact: dhcp_servers
+#
+# Purpose:
+#   Return the DHCP server addresses for all interfaces as a hash.
+#   If the interface that is the default gateway is dhcp assigned, there
+#   will also be a 'system' entry in the hash.
+#
+# Resolution:
+#   Parses the output of nmcli to find the DHCP server for the interface if available
+#
+# Caveats:
+#   Requires nmcli to be available and the interface must use network-manager.
+#
+
+require 'facter'
+require 'facter/util/dhcp_servers'
+
+
+Facter.add(:dhcp_servers) do
+  confine :kernel => :linux
+  confine do
+    Facter::Core::Execution.which('nmcli')
+  end
+
+  setcode do
+    gwdev   = Facter::Util::DHCPServers.gateway_device
+    devices = Facter::Util::DHCPServers.devices
+
+    dhcp_servers = {}
+    devices.each do |device|
+      if server = Facter::Util::DHCPServers.device_dhcp_server(device)
+        dhcp_servers['system'] = server if device == gwdev
+        dhcp_servers[device]   = server
+      end
+    end
+
+    dhcp_servers.keys.length > 0 ? dhcp_servers : nil
+  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,44 @@
+require 'facter/ec2/rest'
+
+Facter.define_fact(:ec2_metadata) do
+  define_resolution(:rest) do
+    confine do
+      Facter.value(:virtual).match /^xen/
+    end
+
+    @querier = Facter::EC2::Metadata.new
+    confine do
+      @querier.reachable?
+    end
+
+    setcode do
+      @querier.fetch
+    end
+  end
+end
+
+Facter.define_fact(:ec2_userdata) do
+  define_resolution(:rest) do
+    confine do
+      Facter.value(:virtual).match /^xen/
+    end
+
+    @querier = Facter::EC2::Userdata.new
+    confine do
+      @querier.reachable?
+    end
+
+    setcode do
+      @querier.fetch
+    end
+  end
+end
+
+# The flattened version of the EC2 facts are deprecated and will be removed in
+# a future release of Facter.
+if (ec2_metadata = Facter.value(:ec2_metadata))
+  ec2_facts = Facter::Util::Values.flatten_structure("ec2", ec2_metadata)
+  ec2_facts.each_pair do |factname, factvalue|
+    Facter.add(factname, :value => factvalue)
+  end
+end

data/lib/facter/ec2/rest.rb

@@ -0,0 +1,130 @@
+require 'timeout'
+require 'open-uri'
+
+module Facter
+  module EC2
+    CONNECTION_ERRORS = [
+      Errno::EHOSTDOWN,
+      Errno::EHOSTUNREACH,
+      Errno::ENETUNREACH,
+      Errno::ECONNABORTED,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ETIMEDOUT,
+    ]
+
+    class Base
+      def reachable?(retry_limit = 3)
+        timeout = 0.2
+        able_to_connect = false
+        attempts = 0
+
+        begin
+          Timeout.timeout(timeout) do
+            open(@baseurl).read
+          end
+          able_to_connect = true
+        rescue OpenURI::HTTPError => e
+          if e.message.match /404 Not Found/i
+            able_to_connect = false
+          else
+            attempts = attempts + 1
+            retry if attempts < retry_limit
+          end
+        rescue Timeout::Error
+          attempts = attempts + 1
+          retry if attempts < retry_limit
+        rescue *CONNECTION_ERRORS
+          attempts = attempts + 1
+          retry if attempts < retry_limit
+        end
+
+        able_to_connect
+      end
+    end
+
+    class Metadata < Base
+
+      DEFAULT_URI = "http://169.254.169.254/latest/meta-data/"
+
+      def initialize(uri = DEFAULT_URI)
+        @baseurl = uri
+      end
+
+      def fetch(path = '')
+        results = {}
+
+        keys = fetch_endpoint(path)
+        keys.each do |key|
+          if key.match(%r[/$])
+            # If a metadata key is suffixed with '/' then it's a general metadata
+            # resource, so we have to recursively look up all the keys in the given
+            # collection.
+            name = key[0..-2]
+            results[name] = fetch("#{path}#{key}")
+          else
+            # This is a simple key/value pair, we can just query the given endpoint
+            # and store the results.
+            ret = fetch_endpoint("#{path}#{key}")
+            results[key] = ret.size > 1 ? ret : ret.first
+          end
+        end
+
+        results
+      end
+
+      # @param path [String] The path relative to the object base url
+      #
+      # @return [Array, NilClass]
+      def fetch_endpoint(path)
+        uri = @baseurl + path
+        body = open(uri).read
+        parse_results(body)
+      rescue OpenURI::HTTPError => e
+        if e.message.match /404 Not Found/i
+          return nil
+        else
+          Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
+          return nil
+        end
+      rescue *CONNECTION_ERRORS => e
+        Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
+        return nil
+      end
+
+      private
+
+      def parse_results(body)
+        lines = body.split("\n")
+        lines.map do |line|
+          if (match = line.match(/^(\d+)=.*$/))
+            # Metadata arrays are formatted like '<index>=<associated key>/', so
+            # we need to extract the index from that output.
+            "#{match[1]}/"
+          else
+            line
+          end
+        end
+      end
+    end
+
+    class Userdata < Base
+      DEFAULT_URI = "http://169.254.169.254/latest/user-data/"
+
+      def initialize(uri = DEFAULT_URI)
+        @baseurl = uri
+      end
+
+      def fetch
+        open(@baseurl).read
+      rescue OpenURI::HTTPError => e
+        if e.message.match /404 Not Found/i
+          return nil
+        else
+          Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
+          return nil
+        end
+      end
+    end
+  end
+end