facter 2.1.0-x64-mingw32

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,24 @@
+# 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(".")
+    elsif host
+      host
+    else
+      nil
+    end
+  end
+end

data/lib/facter/gce.rb

@@ -0,0 +1,16 @@
+require 'facter/gce/metadata'
+
+Facter.define_fact(:gce) do
+  define_resolution(:rest) do
+    confine :virtual => 'gce'
+
+    confine do
+      Facter.json?
+    end
+
+    setcode do
+      querier = Facter::GCE::Metadata.new
+      querier.fetch
+    end
+  end
+end

data/lib/facter/gce/metadata.rb

@@ -0,0 +1,87 @@
+require 'open-uri'
+
+module Facter
+  module GCE
+
+    # @api private
+    class Metadata
+      CONNECTION_ERRORS = [
+        OpenURI::HTTPError,
+        Errno::EHOSTDOWN,
+        Errno::EHOSTUNREACH,
+        Errno::ENETUNREACH,
+        Errno::ECONNABORTED,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::ETIMEDOUT,
+        Timeout::Error,
+      ]
+
+      METADATA_URL = "http://metadata/computeMetadata/v1beta1/?recursive=true&alt=json"
+
+      def initialize(url = METADATA_URL)
+        @url = url
+      end
+
+      def fetch
+        with_metadata_server do |body|
+          # This will only be reached if the confine associated with this class
+          # was true which means that JSON was required, but it's a bit
+          # questionable that we're relying on JSON being loaded as a side
+          # effect of that.
+          hash = ::JSON.parse(body)
+          transform_metadata!(hash)
+          hash
+        end
+      end
+
+      private
+
+      def with_metadata_server
+        retry_limit = 3
+        timeout = 0.05
+        body = nil
+        attempts = 0
+
+        begin
+          Timeout.timeout(timeout) do
+            body = open(@url).read
+          end
+        rescue *CONNECTION_ERRORS => e
+          attempts = attempts + 1
+          if attempts < retry_limit
+            retry
+          else
+            Facter.log_exception(e, "Unable to fetch metadata from #{@url}: #{e.message}")
+            return nil
+          end
+        end
+
+        if body
+          yield body
+        end
+      end
+
+      # @return [void]
+      def transform_metadata!(data)
+        case data
+        when Hash
+          data.keys.each do |key|
+            value = data[key]
+            if ["image", "machineType", "zone", "network"].include? key
+              data[key] = value.split('/').last
+            elsif key == "sshKeys"
+              data['sshKeys'] = value.split("\n")
+            end
+            transform_metadata!(value)
+          end
+        when Array
+          data.each do |value|
+            transform_metadata!(value)
+          end
+        end
+        nil
+      end
+    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

data/lib/facter/hardwaremodel.rb

@@ -0,0 +1,67 @@
+# Fact: hardwaremodel
+#
+# Purpose:
+#   Returns the hardware model of the system.
+#
+# Resolution:
+#   Uses purely "uname -m" on all platforms other than AIX and Windows.
+#   On AIX uses the parsed "modelname" output of "lsattr -El sys0 -a modelname".
+#   On Windows uses the 'host_cpu' pulled out of Ruby's config.
+#
+# Caveats:
+#
+
+Facter.add(:hardwaremodel) do
+  setcode 'uname -m'
+end
+
+Facter.add(:hardwaremodel) do
+  confine :operatingsystem => :aix
+  setcode do
+    model = Facter::Core::Execution.exec('lsattr -El sys0 -a modelname')
+    if model =~ /modelname\s(\S+)\s/
+      $1
+    end
+  end
+end
+
+Facter.add(:hardwaremodel) do
+  confine :operatingsystem => :windows
+  setcode do
+    # The cryptic windows cpu architecture models are documented in these places:
+    # http://source.winehq.org/source/include/winnt.h#L568
+    # http://msdn.microsoft.com/en-us/library/windows/desktop/aa394373(v=vs.85).aspx
+    # http://msdn.microsoft.com/en-us/library/windows/desktop/windows.system.processorarchitecture.aspx
+    # http://linux.derkeiler.com/Mailing-Lists/Kernel/2008-05/msg12924.html (anything over 6 is still i686)
+    # Also, arm and neutral are included because they are valid for the upcoming
+    # windows 8 release.  --jeffweiss 23 May 2012
+    require 'facter/util/wmi'
+    model = ""
+    architecture_level = nil
+
+    Facter::Util::WMI.execquery("select Architecture, Level, AddressWidth from Win32_Processor").each do |cpu|
+      architecture_level = (cpu.Level > 5) ? 6 : cpu.Level;
+
+      model =
+        case cpu.Architecture
+        when 11 then 'neutral'        # PROCESSOR_ARCHITECTURE_NEUTRAL
+        when 10 then 'i686'           # PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
+        when 9 then                   # PROCESSOR_ARCHITECTURE_AMD64
+          cpu.AddressWidth == 32 ? "i#{architecture_level}86" : 'x64' # 32 bit OS on 64 bit CPU
+        when 8 then 'msil'            # PROCESSOR_ARCHITECTURE_MSIL
+        when 7 then 'alpha64'         # PROCESSOR_ARCHITECTURE_ALPHA64
+        when 6 then 'ia64'            # PROCESSOR_ARCHITECTURE_IA64
+        when 5 then 'arm'             # PROCESSOR_ARCHITECTURE_ARM
+        when 4 then 'shx'             # PROCESSOR_ARCHITECTURE_SHX
+        when 3 then 'powerpc'         # PROCESSOR_ARCHITECTURE_PPC
+        when 2 then 'alpha'           # PROCESSOR_ARCHITECTURE_ALPHA
+        when 1 then 'mips'            # PROCESSOR_ARCHITECTURE_MIPS
+        when 0 then "i#{architecture_level}86" # PROCESSOR_ARCHITECTURE_INTEL
+        else 'unknown'            # PROCESSOR_ARCHITECTURE_UNKNOWN
+        end
+      break
+    end
+
+    model
+  end
+end

data/lib/facter/hostname.rb

@@ -0,0 +1,31 @@
+# Fact: hostname
+#
+# Purpose: Return the system's short hostname.
+#
+# Resolution:
+#   On all system bar Darwin, parses the output of the "hostname" system command
+#   to everything before the first period.
+#   On Darwin, uses the system configuration util to get the LocalHostName
+#   variable.
+#
+# Caveats:
+#
+
+Facter.add(:hostname) do
+  setcode do
+    hostname = nil
+    if name = Facter::Core::Execution.execute('hostname')
+      if name =~ /(.*?)\./
+        hostname = $1
+      else
+        hostname = name
+      end
+    end
+    hostname
+  end
+end
+
+Facter.add(:hostname) do
+  confine :kernel => :darwin, :kernelrelease => "R7"
+  setcode '/usr/sbin/scutil --get LocalHostName'
+end

data/lib/facter/id.rb

@@ -0,0 +1,21 @@
+# Fact: id
+#
+# Purpose: Internal fact used to specity the program to return the currently
+# running user id.
+#
+# Resolution:
+#   On all Unixes bar Solaris, just returns "whoami".
+#   On Solaris, parses the output of the "id" command to grab the username, as
+#   Solaris doesn't have the whoami command.
+#
+# Caveats:
+#
+
+Facter.add(:id) do
+  setcode "whoami"
+end
+
+Facter.add(:id) do
+  confine :kernel => :SunOS
+  setcode "/usr/xpg4/bin/id -un"
+end

data/lib/facter/interfaces.rb

@@ -0,0 +1,46 @@
+# Fact: interfaces
+#
+# Purpose:
+#
+# Resolution:
+#
+# Caveats:
+#
+
+# interfaces.rb
+# Try to get additional Facts about the machine's network interfaces
+#
+# Original concept Copyright (C) 2007 psychedelys <psychedelys@gmail.com>
+# Update and *BSD support (C) 2007 James Turnbull <james@lovedthanlost.net>
+#
+
+require 'facter/util/ip'
+require 'facter/util/macaddress'
+
+# Note that most of this only works on a fixed list of platforms; notably, Darwin
+# is missing.
+
+Facter.add(:interfaces) do
+  confine :kernel => Facter::Util::IP.supported_platforms
+  setcode do
+    Facter::Util::IP.get_interfaces.collect { |iface| Facter::Util::IP.alphafy(iface) }.join(",")
+  end
+end
+
+Facter::Util::IP.get_interfaces.each do |interface|
+
+  # Make a fact for each detail of each interface.  Yay.
+  #   There's no point in confining these facts, since we wouldn't be able to create
+  # them if we weren't running on a supported platform.
+  %w{ipaddress ipaddress6 macaddress netmask mtu}.each do |label|
+    Facter.add(label + "_" + Facter::Util::IP.alphafy(interface)) do
+      setcode do
+        value = Facter::Util::IP.get_interface_value(interface, label)
+        if label == "macaddress"
+          value = Facter::Util::Macaddress.standardize(value)
+        end
+        value
+      end
+    end
+  end
+end

data/lib/facter/ipaddress.rb

@@ -0,0 +1,171 @@
+# Fact: ipaddress
+#
+# Purpose: Return the main IP address for a host.
+#
+# Resolution:
+#   On the Unixes does an ifconfig, and returns the first non 127.0.0.0/8
+#   subnetted IP it finds.
+#   On Windows, it attempts to use the socket library and resolve the machine's
+#   hostname via DNS.
+#
+#   On LDAP based hosts it tries to use either the win32/resolv library to
+#   resolve the hostname to an IP address, or on Unix, it uses the resolv
+#   library.
+#
+#   As a fall back for undefined systems, it tries to run the "host" command to
+#   resolve the machine's hostname using the system DNS.
+#
+# Caveats:
+#   DNS resolution relies on working DNS infrastructure and resolvers on the
+#   host system.
+#   The ifconfig parsing purely takes the first IP address it finds without any
+#   checking this is a useful IP address.
+#
+
+require 'facter/util/ip'
+
+Facter.add(:ipaddress) do
+  confine :kernel => :linux
+  setcode do
+    ip = nil
+    output = Facter::Util::IP.exec_ifconfig(["2>/dev/null"])
+    if output
+      regexp = /inet (?:addr:)?([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+      output.split("\n").each do |line|
+        match = regexp.match(line)
+        if match and not /^127\./.match(match[1])
+          ip = match[1]
+          break
+        end
+      end
+    end
+    ip
+  end
+end
+
+Facter.add(:ipaddress) do
+  confine :kernel => %w{FreeBSD OpenBSD Darwin DragonFly}
+  setcode do
+    ip = nil
+    output = Facter::Util::IP.exec_ifconfig
+
+    output.split(/^\S/).each { |str|
+      if str =~ /inet ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+        tmp = $1
+        unless tmp =~ /^127\./
+          ip = tmp
+          break
+        end
+      end
+    }
+
+    ip
+  end
+end
+
+Facter.add(:ipaddress) do
+  confine :kernel => %w{NetBSD SunOS}
+  setcode do
+    ip = nil
+    output = Facter::Util::IP.exec_ifconfig(["-a"])
+
+    output.split(/^\S/).each { |str|
+      if str =~ /inet ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+        tmp = $1
+        unless tmp =~ /^127\./ or tmp == "0.0.0.0"
+          ip = tmp
+          break
+        end
+      end
+    }
+
+    ip
+  end
+end
+
+Facter.add(:ipaddress) do
+  confine :kernel => %w{AIX}
+  setcode do
+    ip = nil
+    output = Facter::Util::IP.exec_ifconfig(["-a"])
+
+    output.split(/^\S/).each { |str|
+      if str =~ /inet ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+        tmp = $1
+        unless tmp =~ /^127\./
+          ip = tmp
+          break
+        end
+      end
+    }
+
+    ip
+  end
+end
+
+Facter.add(:ipaddress) do
+  confine :kernel => %w{windows}
+  setcode do
+    require 'facter/util/ip/windows'
+    ipaddr = nil
+
+    adapters = Facter::Util::IP::Windows.get_preferred_ipv4_adapters
+    adapters.find do |nic|
+      nic.IPAddress.any? do |addr|
+        ipaddr = addr if Facter::Util::IP::Windows.valid_ipv4_address?(addr)
+        ipaddr
+      end
+    end
+
+    ipaddr
+  end
+end
+
+Facter.add(:ipaddress, :timeout => 2) do
+  setcode do
+    if Facter.value(:kernel) == 'windows'
+      require 'win32/resolv'
+    else
+      require 'resolv'
+    end
+
+    begin
+      if hostname = Facter.value(:hostname)
+        if Facter.value(:kernel) == 'windows'
+          ip = Win32::Resolv.get_resolv_info.last[0]
+        else
+          ip = Resolv.getaddress(hostname)
+        end
+        unless ip == "127.0.0.1"
+          ip
+        end
+      else
+        nil
+      end
+    rescue Resolv::ResolvError
+      nil
+    rescue NoMethodError # i think this is a bug in resolv.rb?
+      nil
+    end
+  end
+end
+
+Facter.add(:ipaddress, :timeout => 2) do
+  setcode do
+    if hostname = Facter.value(:hostname)
+      # we need Hostname to exist for this to work
+      host = nil
+      if host = Facter::Core::Execution.execute("host #{hostname}")
+        list = host.chomp.split(/\s/)
+        if defined? list[-1] and
+          list[-1] =~ /[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/
+          list[-1]
+        end
+      else
+        nil
+      end
+    else
+      nil
+    end
+  end
+end