facter 1.6.18 → 1.7.0.rc1

data/lib/facter/domain.rb

@@ -23,14 +23,24 @@ Facter.add(:domain) do
     # Get the domain from various sources; the order of these
     # steps is important
 
-    if name = Facter::Util::Resolution.exec('hostname') \
+    # 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
+    hostname_command = 'hostname'
+    can_do_hostname_f = Regexp.union /Linux/i, /FreeBSD/i, /Darwin/i
+    hostname_command = 'hostname -f' if Facter.value(:kernel) =~ can_do_hostname_f
+
+       
+    if name = Facter::Util::Resolution.exec(hostname_command) \
       and name =~ /.*?\.(.+$)/
 
-      $1
+      return_value = $1
     elsif domain = Facter::Util::Resolution.exec('dnsdomainname') \
-      and domain =~ /.+\..+/
+      and domain =~ /.+/
 
-      domain
+      return_value = domain
     elsif FileTest.exists?("/etc/resolv.conf")
       domain = nil
       search = nil
@@ -43,9 +53,11 @@ Facter.add(:domain) do
           end
         }
       }
-      next domain if domain
-      next search if search
+      return_value ||= domain
+      return_value ||= search
     end
+    return_value = '' if return_value.nil?
+    return_value.gsub(/\.$/, '')
   end
 end
 
@@ -63,6 +75,6 @@ Facter.add(:domain) do
         break
       }
     end
-    domain
+    domain.gsub(/\.$/, '')
   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::Util::Resolution.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/hardwaremodel.rb

@@ -36,12 +36,13 @@ Facter.add(:hardwaremodel) do
     # windows 8 release.  --jeffweiss 23 May 2012
     require 'facter/util/wmi'
     model = ""
-    Facter::Util::WMI.execquery("select Architecture, Level from Win32_Processor").each do |cpu|
+    Facter::Util::WMI.execquery("select Architecture, Level, AddressWidth from Win32_Processor").each do |cpu|
       model =
         case cpu.Architecture
         when 11 then 'neutral'        # PROCESSOR_ARCHITECTURE_NEUTRAL
         when 10 then 'i686'           # PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
-        when 9 then 'x64'             # PROCESSOR_ARCHITECTURE_AMD64
+        when 9 then                   # PROCESSOR_ARCHITECTURE_AMD64
+          cpu.AddressWidth == 32 ? "i#{cpu.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

data/lib/facter/ipaddress6.rb

@@ -39,8 +39,7 @@ Facter.add(:ipaddress6) do
   confine :kernel => :linux
   setcode do
     output = Facter::Util::IP.exec_ifconfig(["2>/dev/null"])
-
-    get_address_after_token(output, 'inet6 addr:')
+    get_address_after_token(output, 'inet6(?: addr:)?')
   end
 end
 

data/lib/facter/kernelrelease.rb

@@ -16,12 +16,20 @@ Facter.add(:kernelrelease) do
 end
 
 Facter.add(:kernelrelease) do
-  confine :kernel => :aix
+  confine :kernel => "aix"
   setcode 'oslevel -s'
 end
 
 Facter.add(:kernelrelease) do
-  confine :kernel => %{windows}
+  confine :kernel => "hp-ux"
+  setcode do
+    version = Facter::Util::Resolution.exec('uname -r') 
+    version[2..-1]
+  end
+end
+
+Facter.add(:kernelrelease) do
+  confine :kernel => "windows"
   setcode do
     require 'facter/util/wmi'
     version = ""

data/lib/facter/ldom.rb

@@ -0,0 +1,47 @@
+if Facter.value(:kernel) == 'SunOS'
+  virtinfo = Facter::Util::Resolution.exec('virtinfo -ap')
+
+  # Convert virtinfo parseable output format to array of arrays.
+  # DOMAINROLE|impl=LDoms|control=true|io=true|service=true|root=true
+  # DOMAINNAME|name=primary
+  # DOMAINUUID|uuid=8e0d6ec5-cd55-e57f-ae9f-b4cc050999a4
+  # DOMAINCONTROL|name=san-t2k-6
+  # DOMAINCHASSIS|serialno=0704RB0280
+  #
+  # For keys containing multiple value such as domain role:
+  # ldom_{key}_{subkey} = value
+  # Otherwise the fact will simply be:
+  # ldom_{key} = value
+  unless virtinfo.nil?
+    virt_array = virtinfo.split("\n").select{|l| l =~ /^DOMAIN/ }.
+      collect{|l| l.split('|')}
+    virt_array.each do |x|
+      key = x[0]
+      value = x[1..x.size]
+
+      if value.size == 1
+        Facter.add("ldom_#{key.downcase}") do
+          setcode { value.first.split('=')[1] }
+        end
+      else
+        value.each do |y|
+          k = y.split('=')[0]
+          v = y.split('=')[1]
+          Facter.add("ldom_#{key.downcase}_#{k.downcase}") do
+            setcode { v }
+          end
+        end
+      end
+    end
+
+    # When ldom domainrole control = false, the system is a guest, so we mark it
+    # as a virtual system:
+    Facter.add("virtual") do
+      confine :ldom_domainrole_control => 'false'
+      has_weight 10
+      setcode do
+        Facter.value(:ldom_domainrole_impl)
+      end
+    end
+  end
+end

data/lib/facter/macaddress.rb

@@ -49,7 +49,7 @@ Facter.add(:macaddress) do
 end
 
 Facter.add(:macaddress) do
-  confine :operatingsystem => "Solaris"
+  confine :osfamily => "Solaris"
   setcode do
     ether = []
     output = Facter::Util::Resolution.exec("/usr/bin/netstat -np")

data/lib/facter/manufacturer.rb

@@ -47,10 +47,16 @@ else
       { 'Product(?: Name)?:' => 'boardproductname' },
       { 'Serial Number:'   => 'boardserialnumber' }
     ],
+    '[Bb][Ii][Oo][Ss] [Ii]nformation' => [
+      { '[Vv]endor:' => 'bios_vendor' },
+      { '[Vv]ersion:' => 'bios_version' },
+      { '[Rr]elease [Dd]ate:' => 'bios_release_date' }
+    ],
     '[Ss]ystem [Ii]nformation' => [
       { 'Manufacturer:'    => 'manufacturer' },
       { 'Product(?: Name)?:' => 'productname' },
-      { 'Serial Number:'   => 'serialnumber' }
+      { 'Serial Number:'   => 'serialnumber' },
+      { 'UUID:'   => 'uuid' }
     ],
     '(Chassis Information|system enclosure or chassis)' => [
       { '(?:Chassis )?Type:' => 'type' }

data/lib/facter/memory.rb

@@ -8,6 +8,8 @@
 #   On AIX, parses "swap -l" for swap values only.
 #   On OpenBSD, it parses "swapctl -l" for swap values, vmstat via a module for
 #   free memory, and "sysctl hw.physmem" for maximum memory.
+#   On FreeBSD, it parses "swapinfo -k" for swap values, and parses sysctl for
+#   maximum memory.
 #   On Solaris, use "swap -l" for swap values, and parsing prtconf for maximum
 #   memory, and again, the vmstat module for free memory.
 #
@@ -22,227 +24,132 @@
 # Author: Matthew Palmer <matt@solutionsfirst.com.au>
 #
 #
+
 require 'facter/util/memory'
 
-{   :MemorySize => "MemTotal",
-    :MemoryFree => "MemFree",
-    :SwapSize   => "SwapTotal",
-    :SwapFree   => "SwapFree"
-}.each do |fact, name|
+[  "memorysize",
+   "memoryfree",
+   "swapsize",
+   "swapfree"
+].each do |fact|
   Facter.add(fact) do
-    confine :kernel => [ :linux, :"gnu/kfreebsd" ]
     setcode do
-      Facter::Memory.meminfo_number(name)
+      name = Facter.fact(fact + "_mb").value
+      Facter::Memory.scale_number(name.to_f, "MB") if name
     end
   end
 end
 
-Facter.add("SwapSize") do
-  confine :kernel => :Darwin
+Facter.add("swapsize_mb") do
   setcode do
-    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
-    swaptotal = 0
-    if swap =~ /total = (\S+)/ then swaptotal = $1; end
-    swaptotal
+    swaptotal = Facter::Memory.swap_size
+    "%.2f" % [swaptotal] if swaptotal
   end
 end
 
-Facter.add("SwapFree") do
-  confine :kernel => :Darwin
+Facter.add("swapfree_mb") do
   setcode do
-    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
-    swapfree = 0
-    if swap =~ /free = (\S+)/ then swapfree = $1; end
-    swapfree
+    swapfree = Facter::Memory.swap_free
+    "%.2f" % [swapfree] if swapfree
   end
 end
 
-Facter.add("SwapEncrypted") do
-  confine :kernel => :Darwin
+Facter.add("memorysize_mb") do
   setcode do
-    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
-    encrypted = false
-    if swap =~ /\(encrypted\)/ then encrypted = true; end
-    encrypted
+    memtotal = Facter::Memory.mem_size
+    "%.2f" % [memtotal] if memtotal
   end
 end
 
-if Facter.value(:kernel) == "AIX" and Facter.value(:id) == "root"
-  swap = Facter::Util::Resolution.exec('swap -l')
-  swapfree, swaptotal = 0, 0
-  swap.each_line do |dev|
-    if dev =~ /^\/\S+\s.*\s+(\S+)MB\s+(\S+)MB/
-      swaptotal += $1.to_i
-      swapfree  += $2.to_i
-    end
-  end
-
-  Facter.add("SwapSize") do
-    confine :kernel => :aix
-    setcode do
-      Facter::Memory.scale_number(swaptotal.to_f,"MB")
-    end
-  end
-
-  Facter.add("SwapFree") do
-    confine :kernel => :aix
-    setcode do
-      Facter::Memory.scale_number(swapfree.to_f,"MB")
-    end
+Facter.add("memoryfree_mb") do
+  setcode do
+    memfree = Facter::Memory.mem_free
+    "%.2f" % [memfree] if memfree
   end
 end
 
-if Facter.value(:kernel) == "OpenBSD"
-  swap = Facter::Util::Resolution.exec('swapctl -s')
-  swapfree, swaptotal = 0, 0
-  if swap =~ /^total: (\d+)k bytes allocated = \d+k used, (\d+)k available$/
-    swaptotal = $1.to_i
-    swapfree  = $2.to_i
-  end
-
-  Facter.add("SwapSize") do
-    confine :kernel => :openbsd
-    setcode do
-      Facter::Memory.scale_number(swaptotal.to_f,"kB")
-    end
-  end
-
-  Facter.add("SwapFree") do
-    confine :kernel => :openbsd
-    setcode do
-      Facter::Memory.scale_number(swapfree.to_f,"kB")
-    end
-  end
-
-  Facter::Memory.vmstat_find_free_memory()
-
-  Facter.add("memorysize") do
-    confine :kernel => :openbsd
-    memtotal = Facter::Util::Resolution.exec("sysctl hw.physmem | cut -d'=' -f2")
+{   :memorysize_mb => "MemTotal",
+    :memoryfree_mb => "MemFree",
+    :swapsize_mb   => "SwapTotal",
+    :swapfree_mb   => "SwapFree"
+}.each do |fact, name|
+  Facter.add(fact) do
+    confine :kernel => [ :linux, :"gnu/kfreebsd" ]
     setcode do
-      Facter::Memory.scale_number(memtotal.to_f,"")
+      meminfo = Facter::Memory.meminfo_number(name)
+      "%.2f" % [meminfo]
     end
   end
 end
 
 if Facter.value(:kernel) == "Darwin"
-  swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
-  swapfree, swaptotal = 0, 0
-  unless swap.empty?
-    # Parse the line:
-    # vm.swapusage: total = 128.00M  used = 0.37M  free = 127.63M  (encrypted)
-    if swap =~ /total\s=\s(\S+)\s+used\s=\s(\S+)\s+free\s=\s(\S+)\s/
-      swaptotal += $1.to_i
-      swapfree  += $3.to_i
-    end
-  end
-
-  Facter.add("SwapSize") do
-    confine :kernel => :Darwin
-    setcode do
-      Facter::Memory.scale_number(swaptotal.to_f,"MB")
-    end
-  end
-
-  Facter.add("SwapFree") do
+  Facter.add("SwapEncrypted") do
     confine :kernel => :Darwin
     setcode do
-      Facter::Memory.scale_number(swapfree.to_f,"MB")
-    end
-  end
-
-  Facter::Memory.vmstat_darwin_find_free_memory()
-
-  Facter.add("memorysize") do
-    confine :kernel => :Darwin
-    memtotal = Facter::Util::Resolution.exec("sysctl hw.memsize | cut -d':' -f2")
-    setcode do
-      Facter::Memory.scale_number(memtotal.to_f,"")
+      swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
+      encrypted = false
+      if swap =~ /\(encrypted\)/ then encrypted = true; end
+      encrypted
     end
   end
 end
 
 if Facter.value(:kernel) == "SunOS"
-  swap = Facter::Util::Resolution.exec('/usr/sbin/swap -l')
-  swapfree, swaptotal = 0, 0
-  swap.each_line do |dev|
-    if dev =~ /^\/\S+\s.*\s+(\d+)\s+(\d+)$/
-      swaptotal += $1.to_i / 2
-      swapfree  += $2.to_i / 2
-    end
-  end
 
-  Facter.add("SwapSize") do
+  Facter.add("memorysize_mb") do
     confine :kernel => :sunos
-    setcode do
-      Facter::Memory.scale_number(swaptotal.to_f,"kB")
+    # Total memory size available from prtconf
+    pconf = Facter::Util::Resolution.exec('/usr/sbin/prtconf 2>/dev/null')
+    phymem = ""
+    pconf.each_line do |line|
+      if line =~ /^Memory size:\s+(\d+) Megabytes/
+        phymem = $1
+      end
     end
-  end
-
-  Facter.add("SwapFree") do
-    confine :kernel => :sunos
     setcode do
-      Facter::Memory.scale_number(swapfree.to_f,"kB")
+      "%.2f" % [phymem.to_f]
     end
   end
-
-  # Total memory size available from prtconf
-  pconf = Facter::Util::Resolution.exec('/usr/sbin/prtconf 2>/dev/null')
-  phymem = ""
-  pconf.each_line do |line|
-    if line =~ /^Memory size:\s+(\d+) Megabytes/
-      phymem = $1
-    end
-  end
-
-  Facter.add("MemorySize") do
-    confine :kernel => :sunos
-    setcode do
-      Facter::Memory.scale_number(phymem.to_f,"MB")
-    end
-  end
-
-  Facter::Memory.vmstat_find_free_memory()
 end
 
 if Facter.value(:kernel) == "windows"
   require 'facter/util/wmi'
 
-  Facter.add("MemoryFree") do
+  Facter.add("memorysize_mb") do
     confine :kernel => :windows
     setcode do
       mem = 0
-      Facter::Util::WMI.execquery("select FreePhysicalMemory from Win32_OperatingSystem").each do |os|
-        mem = os.FreePhysicalMemory
+      Facter::Util::WMI.execquery("select TotalPhysicalMemory from Win32_ComputerSystem").each do |comp|
+        mem = comp.TotalPhysicalMemory
         break
       end
-      Facter::Memory.scale_number(mem.to_f, "kB")
+      "%.2f" % [(mem.to_f / 1024.0) / 1024.0]
     end
   end
 
-  Facter.add("memorysize") do
+  Facter.add("memoryfree_mb") do
     confine :kernel => :windows
     setcode do
       mem = 0
-      Facter::Util::WMI.execquery("select TotalPhysicalMemory from Win32_ComputerSystem").each do |comp|
-        mem = comp.TotalPhysicalMemory
+      Facter::Util::WMI.execquery("select FreePhysicalMemory from Win32_OperatingSystem").each do |os|
+        mem = os.FreePhysicalMemory
         break
       end
-      Facter::Memory.scale_number(mem.to_f, "")
+      "%.2f" % [mem.to_f / 1024.0]
     end
   end
 end
 
-Facter.add("SwapSize") do
+Facter.add("swapsize_mb") do
   confine :kernel => :dragonfly
   setcode do
     page_size = Facter::Util::Resolution.exec("/sbin/sysctl -n hw.pagesize").to_f
     swaptotal = Facter::Util::Resolution.exec("/sbin/sysctl -n vm.swap_size").to_f * page_size
-    Facter::Memory.scale_number(swaptotal.to_f,"")
+    "%.2f" % [(swaptotal.to_f / 1024.0) / 1024.0]
   end
 end
 
-Facter.add("SwapFree") do
+Facter.add("swapfree_mb") do
   confine :kernel => :dragonfly
   setcode do
     page_size = Facter::Util::Resolution.exec("/sbin/sysctl -n hw.pagesize").to_f
@@ -250,16 +157,7 @@ Facter.add("SwapFree") do
     swap_anon_use = Facter::Util::Resolution.exec("/sbin/sysctl -n vm.swap_anon_use").to_f * page_size
     swap_cache_use = Facter::Util::Resolution.exec("/sbin/sysctl -n vm.swap_cache_use").to_f * page_size
     swapfree = swaptotal - swap_anon_use - swap_cache_use
-    Facter::Memory.scale_number(swapfree.to_f,"")
-  end
-end
-
-Facter.add("memorysize") do
-  confine :kernel => :dragonfly
-  setcode do
-    Facter::Memory.vmstat_find_free_memory()
-    memtotal = Facter::Util::Resolution.exec("sysctl -n hw.physmem")
-    Facter::Memory.scale_number(memtotal.to_f,"")
+    "%.2f" % [(swapfree.to_f / 1024.0) / 1024.0]
   end
 end