facter 2.1.0-universal-darwin → 2.2.0-universal-darwin

data/lib/facter/osfamily.rb

@@ -3,35 +3,16 @@
 # Purpose: Returns the operating system
 #
 # Resolution:
-#   Maps operating systems to operating system families, such as linux
+#   Uses the family key of the os structured fact, which itself
+#   maps operating systems to operating system families, such as Linux
 #   distribution derivatives. Adds mappings from specific operating systems
 #   to kernels in the case that it is relevant.
 #
 # Caveats:
 #   This fact is completely reliant on the operatingsystem fact, and no
-#   heuristics are used
+#   heuristics are used.
 #
 
 Facter.add(:osfamily) do
-
-  setcode do
-    case Facter.value(:operatingsystem)
-    when "RedHat", "Fedora", "CentOS", "Scientific", "SLC", "Ascendos", "CloudLinux", "PSBM", "OracleLinux", "OVS", "OEL", "Amazon", "XenServer"
-      "RedHat"
-    when "LinuxMint", "Ubuntu", "Debian", "CumulusLinux"
-      "Debian"
-    when "SLES", "SLED", "OpenSuSE", "SuSE"
-      "Suse"
-    when "Solaris", "Nexenta", "OmniOS", "OpenIndiana", "SmartOS"
-      "Solaris"
-    when "Gentoo"
-      "Gentoo"
-    when "Archlinux"
-      "Archlinux"
-    when "Mageia", "Mandriva", "Mandrake"
-      "Mandrake"
-    else
-      Facter.value("kernel")
-    end
-  end
+  setcode { Facter.value("os")["family"] }
 end

data/lib/facter/partitions.rb

@@ -1,14 +1,15 @@
 # Fact: partitions
 #
 # Purpose:
-#   Return the details of the disk partitions
+#   Return the details of the disk partitions.
 #
 # Resolution:
-#   Parse the contents of /sys/block/<device>/size to receive the size (multiplying by 512 to correct for blocks-to-bytes)
+#   Parse the contents of `/sys/block/<device>/size` to receive the size (multiplying by 512 to correct for blocks-to-bytes).
 #
 # Caveats:
-#   Only supports Linux 2.6+ at this time, due to the reliance on sysfs
+#   For Linux, only 2.6+ is supported at this time due to the reliance on sysfs.
 #
+
 # Author: Chris Portman <chris@portman.net.au>
 
 require 'facter'

data/lib/facter/path.rb

@@ -1,8 +1,8 @@
 # Fact: path
 #
-# Purpose: Returns the $PATH variable.
+# Purpose: Returns the `$PATH` variable.
 #
-# Resolution: Gets $PATH from the environment.
+# Resolution: Gets `$PATH` from the environment.
 #
 # Caveats:
 #

data/lib/facter/physicalprocessorcount.rb

@@ -3,89 +3,25 @@
 # Purpose: Return the number of physical processors.
 #
 # Resolution:
-#
-#   Attempts to use sysfs to get the physical IDs of the processors. Falls
-#   back to /proc/cpuinfo and "physical id" if sysfs is not available.
+#   Uses the physicalprocessorcount key of the processors structured
+#   fact, which itself attempts to use sysfs to get the physical IDs of
+#   the processors and falls back to `/proc/cpuinfo` and `physical id` if
+#   sysfs is not available.
 #
 # Caveats:
 #
-require 'facter/util/posix'
-
-Facter.add('physicalprocessorcount') do
-  confine :kernel => :linux
-
-  setcode do
-    sysfs_cpu_directory = '/sys/devices/system/cpu' # This should always be there ...
-
-    if File.exists?(sysfs_cpu_directory)
-      #
-      # We assume that the sysfs file system has the correct number of entries
-      # under the "/sys/device/system/cpu" directory and if so then we process
-      # content of the file "physical_package_id" located inside the "topology"
-      # directory in each of the per-CPU sub-directories.
-      #
-      # As per Linux Kernel documentation and the file "cputopology.txt" located
-      # inside the "/usr/src/linux/Documentation" directory we can find following
-      # short explanation:
-      #
-      # (...)
-      #
-      # 1) /sys/devices/system/cpu/cpuX/topology/physical_package_id:
-      #
-      #         physical package id of cpuX. Typically corresponds to a physical
-      #         socket number, but the actual value is architecture and platform
-      #         dependent.
-      #
-      # (...)
-      #
-      lookup_pattern = "#{sysfs_cpu_directory}" +
-        "/cpu*/topology/physical_package_id"
-
-      Dir.glob(lookup_pattern).collect { |f| Facter::Core::Execution.exec("cat #{f}")}.uniq.size.to_s
-
-    else
-      #
-      # Try to count number of CPUs using the proc file system next ...
-      #
-      # We assume that /proc/cpuinfo has what we need and is so then we need
-      # to make sure that we only count unique entries ...
-      #
-      str = Facter::Core::Execution.exec("grep 'physical.\\+:' /proc/cpuinfo")
-
-      if str then str.scan(/\d+/).uniq.size.to_s; end
-    end
-  end
-end
 
 Facter.add('physicalprocessorcount') do
-  confine :kernel => :windows
-  setcode do
-    require 'facter/util/wmi'
-    Facter::Util::WMI.execquery("select Name from Win32_Processor").Count.to_s
+  confine do
+    !Facter.value(:processors).nil?
   end
-end
-
-Facter.add('physicalprocessorcount') do
-  confine :kernel => :sunos
 
-  # (#16526) The -p flag was not added until Solaris 8.  Our intent is to
-  # split the kernel release fact value on the dot, take the second element,
-  # and disable the -p flag for values < 8 when.
   setcode do
-    kernelrelease = Facter.value(:kernelrelease)
-    (major_version, minor_version) = kernelrelease.split(".").map { |str| str.to_i }
-    if (major_version > 5) or (major_version == 5 and minor_version >= 8) then
-      Facter::Core::Execution.exec("/usr/sbin/psrinfo -p")
+    processors = Facter.value(:processors)
+    if (physicalprocessorcount = processors["physicalcount"])
+      physicalprocessorcount.to_s
     else
-      output = Facter::Core::Execution.exec("/usr/sbin/psrinfo")
-      output.split("\n").length.to_s
+      nil
     end
   end
 end
-
-Facter.add('physicalprocessorcount') do
-  confine :kernel => :openbsd
-  setcode do
-    Facter::Util::POSIX.sysctl("hw.ncpufound")
-  end
-end

data/lib/facter/processor.rb

@@ -4,11 +4,9 @@
 #   Additional Facts about the machine's CPUs.
 #
 # Resolution:
-#   On Linux and kFreeBSD, parse '/proc/cpuinfo' for each processor.
-#   On AIX, parse the output of 'lsdev' for its processor section.
-#   On Solaris, parse the output of 'kstat' for each processor.
-#   On OpenBSD, use the sysctl variables 'hw.model' and 'hw.ncpu'
-#   for the CPU model and the CPU count respectively.
+#   Utilizes values from the processors structured fact, which itself 
+#   uses various methods to collect CPU information, with implementation 
+#   dependent upon the OS of the system in question.
 #
 # Caveats:
 #
@@ -19,115 +17,29 @@
 # Author: Matthew Palmer <matt@solutionsfirst.com.au>
 #
 
-require 'thread'
-require 'facter/util/processor'
-require 'facter/util/posix'
 
 # We have to enumerate these outside a Facter.add block to get the processorN
 # descriptions iteratively (but we need them inside the Facter.add block above
 # for tests on processorcount to work)
-processor_list = case Facter::Util::Processor.kernel_fact_value
-when "AIX"
-  Facter::Util::Processor.aix_processor_list
-when "HP-UX"
-  Facter::Util::Processor.hpux_processor_list
-when "SunOS"
-  Facter::Util::Processor.enum_kstat
-else
-  Facter::Util::Processor.enum_cpuinfo
-end
-
-processor_list.each_with_index do |desc, i|
-  Facter.add("Processor#{i}") do
-    confine :kernel => [ :aix, :"hp-ux", :sunos, :linux, :"gnu/kfreebsd" ]
-    setcode do
-      desc
-    end
-  end
-end
-
-Facter.add("ProcessorCount") do
-  confine :kernel => [ :linux, :"gnu/kfreebsd" ]
-  setcode do
-    processor_list = Facter::Util::Processor.enum_cpuinfo
-
-    ## If this returned nothing, then don't resolve the fact
-    if processor_list.length != 0
-      processor_list.length.to_s
-    end
-  end
-end
-
-Facter.add("ProcessorCount") do
-  confine :kernel => [ :linux, :"gnu/kfreebsd" ]
-  setcode do
-    ## The method above is preferable since it provides the description of the CPU as well
-    ## but if that returned 0, then we enumerate sysfs
-    sysfs_cpu_directory = '/sys/devices/system/cpu'
-    if File.exists?(sysfs_cpu_directory)
-      lookup_pattern = "#{sysfs_cpu_directory}" + "/cpu[0-9]*"
-      cpuCount = Dir.glob(lookup_pattern).length
-      cpuCount.to_s
+processors = Facter.value(:processors)
+if processors && (processor_list = processors["models"])
+  processor_list.each_with_index do |processor, i|
+    Facter.add("processor#{i}") do
+      setcode { processor }
     end
   end
 end
 
 Facter.add("ProcessorCount") do
-  confine :kernel => :aix
-  setcode do
-    processor_list = Facter::Util::Processor.aix_processor_list
-
-    processor_list.length.to_s
+  confine do
+    !Facter.value(:processors).nil?
   end
-end
 
-Facter.add("ProcessorCount") do
-  confine :kernel => :"hp-ux"
   setcode do
-    processor_list = Facter::Util::Processor.hpux_processor_list
-    processor_list.length.to_s
-  end
-end
-
-Facter.add("ProcessorCount") do
-  confine :kernel => :Darwin
-  setcode do
-    Facter::Util::POSIX.sysctl("hw.ncpu")
-  end
-end
-
-if Facter.value(:kernel) == "windows"
-  processor_list = []
-
-  require 'facter/util/wmi'
-
-  # get each physical processor
-  Facter::Util::WMI.execquery("select * from Win32_Processor").each do |proc|
-    # not supported before 2008
-    if proc.respond_to?(:NumberOfLogicalProcessors)
-      processor_num = proc.NumberOfLogicalProcessors
+    if (processorcount = processors["count"])
+      processorcount.to_s
     else
-      processor_num = 1
-    end
-
-    processor_num.times do |i|
-      processor_list << proc.Name.squeeze(" ")
-    end
-  end
-
-  processor_list.each_with_index do |name, i|
-    Facter.add("Processor#{i}") do
-      confine :kernel => :windows
-      setcode do
-        name
-      end
-    end
-  end
-
-  Facter.add("ProcessorCount") do
-    confine :kernel => :windows
-    setcode do
-      processor_list.length.to_s
+      nil
     end
   end
 end
@@ -138,31 +50,3 @@ Facter.add("Processor") do
     Facter::Util::POSIX.sysctl("hw.model")
   end
 end
-
-Facter.add("ProcessorCount") do
-  confine :kernel => [:dragonfly,:freebsd,:openbsd]
-  setcode do
-    Facter::Util::POSIX.sysctl("hw.ncpu")
-  end
-end
-
-Facter.add("ProcessorCount") do
-  confine :kernel => :sunos
-  setcode do
-    kernelrelease = Facter.value(:kernelrelease)
-    (major_version, minor_version) = kernelrelease.split(".").map { |str| str.to_i }
-    result = nil
-
-    if (major_version < 5) or (major_version == 5 and minor_version < 8) then
-      if kstat = Facter::Core::Execution.exec("/usr/bin/kstat cpu_info")
-        result = kstat.scan(/\bcore_id\b\s+\d+/).uniq.length
-      end
-    else
-      if output = Facter::Core::Execution.exec("/usr/sbin/psrinfo") then
-        result = output.split("\n").length
-      end
-    end
-
-    result.to_s
-  end
-end

data/lib/facter/processors.rb

@@ -0,0 +1,60 @@
+# Fact: processors
+#
+# Purpose:
+#   Additional facts about the machine's CPU's, including
+#   processor lists, models, counts, and speeds.
+#
+# Resolution:
+#   Each kernel utilizes its own implementation object to collect
+#   processor data. Linux and kFreeBSD parse `/proc/cpuinfo` for each
+#   processor. AIX parses the output of `lsdev` for its processor section.
+#   For Solaris, we parse the output of `kstat` for each processor. OpenBSD uses
+#   the sysctl variables 'hw.model' and 'hw.ncpu' for the CPU model and 
+#   the CPU count respectively. Darwin utilizes the system profiler to collect
+#   the physical CPU count and speed.
+#
+
+require 'facter/processors/os'
+
+Facter.add(:processors, :type => :aggregate) do
+  confine do
+    !os.nil?
+  end
+
+  def os
+    @os ||= Facter::Processors.implementation
+  end
+
+  chunk(:models) do
+    processor_hash = {}
+    processor_list = os.get_processor_list
+    if processor_list.length > 0
+      processor_hash["models"] = processor_list
+      processor_hash
+    end
+  end
+
+  chunk(:count) do
+    processor_hash = {}
+    if (processor_count = os.get_processor_count)
+      processor_hash["count"] = processor_count
+      processor_hash
+    end
+  end
+
+  chunk(:physicalcount) do
+    processor_hash = {}
+    if (physical_processor_count = os.get_physical_processor_count)
+      processor_hash["physicalcount"] = physical_processor_count
+      processor_hash
+    end
+  end
+
+  chunk(:speed) do
+    processor_hash = {}
+    if (processor_speed = os.get_processor_speed)
+      processor_hash["speed"] = processor_speed
+      processor_hash
+    end
+  end
+end

data/lib/facter/processors/os.rb

@@ -0,0 +1,234 @@
+# Processor OS classes
+#
+# Implements processor data collection with the help
+# of the Util::Processor module.
+
+require 'facter/util/processor'
+require 'facter/util/posix'
+
+module Facter
+  module Processors
+
+    def self.implementation(kernel = Facter.value(:kernel))
+      case kernel
+      when "Linux"
+        Facter::Processors::Linux.new
+      when "GNU/kFreeBSD"
+        Facter::Processors::GNU.new
+      when "Darwin"
+        Facter::Processors::Darwin.new
+      when "AIX"
+        Facter::Processors::AIX.new
+      when "HP-UX"
+        Facter::Processors::HP_UX.new
+      when "DragonFly", "FreeBSD"
+        Facter::Processors::BSD.new
+      when "OpenBSD"
+        Facter::Processors::OpenBSD.new
+      when "SunOS"
+        Facter::Processors::SunOS.new
+      when "windows"
+        Facter::Processors::Windows.new
+      end
+    end
+
+    class Base
+      def get_processor_list
+        Facter::Util::Processor.enum_cpuinfo
+      end
+
+      def get_processor_count
+        get_processor_list.length
+      end
+
+      def get_physical_processor_count
+        nil
+      end
+
+      def get_processor_speed
+        nil
+      end
+    end
+
+    class GNU < Base
+      def get_processor_count
+        processor_list = get_processor_list
+        if processor_list.length != 0
+          processor_list.length
+        else
+          count_cpu_from_sysfs
+        end
+      end
+
+      private
+
+      def count_cpu_from_sysfs
+        sysfs_cpu_directory = "/sys/devices/system/cpu"
+        if File.exists?(sysfs_cpu_directory)
+          lookup_pattern = "#{sysfs_cpu_directory}" + "/cpu[0-9]*"
+          Dir.glob(lookup_pattern).length
+        end
+      end
+    end
+
+    class Linux < GNU
+      def get_physical_processor_count
+        if count = count_physical_cpu_from_sysfs
+          count
+        else
+          count_physical_cpu_from_cpuinfo
+        end
+      end
+
+      private
+
+      def count_physical_cpu_from_sysfs
+        sysfs_cpu_directory = "/sys/devices/system/cpu"
+        if File.exists?(sysfs_cpu_directory)
+          lookup_pattern = "#{sysfs_cpu_directory}" + "/cpu*/topology/physical_package_id"
+          Dir.glob(lookup_pattern).collect { |f| Facter::Core::Execution.exec("cat #{f}")}.uniq.size
+        else
+          nil
+        end
+      end
+
+      def count_physical_cpu_from_cpuinfo
+        str = Facter::Core::Execution.exec("grep 'physical.\+:' /proc/cpuinfo")
+        if str
+          str.scan(/\d+/).uniq.size
+        else
+          nil
+        end
+      end
+    end
+
+    class Windows < Base
+      def initialize
+        require 'facter/util/wmi'
+      end
+
+      def get_processor_list
+        processor_list = []
+        # get each physical processor
+        Facter::Util::WMI.execquery("select * from Win32_Processor").each do |proc|
+          # not supported before 2008
+          if proc.respond_to?(:NumberOfLogicalProcessors)
+            processor_num = proc.NumberOfLogicalProcessors
+          else
+            processor_num = 1
+          end
+
+          processor_num.times do |i|
+            processor_list << proc.Name.squeeze(" ")
+          end
+        end
+        processor_list
+      end
+
+      def get_physical_processor_count
+         Facter::Util::WMI.execquery("select Name from Win32_Processor").Count
+      end
+    end
+
+    class AIX < Base
+      def get_processor_list
+        Facter::Util::Processor.aix_processor_list
+      end
+    end
+
+    class HP_UX < Base
+      def get_processor_list
+        Facter::Util::Processor.hpux_processor_list
+      end
+    end
+
+    class Darwin < Base
+      def initialize
+        require "cfpropertylist"
+        @system_hardware_data = query_system_profiler
+      end
+
+      def get_processor_count
+        Facter::Util::POSIX.sysctl("hw.ncpu").to_i
+      end
+
+      def get_processor_speed
+        @system_hardware_data["current_processor_speed"]
+      end
+
+      private
+
+      def query_system_profiler
+        output = Facter::Core::Execution.exec("/usr/sbin/system_profiler -xml SPHardwareDataType")
+        plist  = CFPropertyList::List.new
+        plist.load_str(output)
+        parsed_xml = CFPropertyList.native_types(plist.value)
+        parsed_xml[0]['_items'][0]
+      end
+    end
+
+    class BSD < Base
+      def get_processor_count
+        Facter::Util::POSIX.sysctl("hw.ncpu").to_i
+      end
+    end
+
+    class OpenBSD < BSD
+      def get_physical_processor_count
+        Facter::Util::POSIX.sysctl("hw.ncpufound").to_i
+      end
+    end
+
+    class SunOS < Base
+      def initialize
+        kernelrelease = Facter.value(:kernelrelease)
+        @major_version = kernelrelease.split(".")[0].to_i
+        @minor_version = kernelrelease.split(".")[1].to_i
+      end
+
+      def get_processor_list
+        Facter::Util::Processor.enum_kstat
+      end
+
+      def get_processor_count
+        if @major_version < 5 or (@major_version == 5 and @minor_version < 8)
+          if count = count_cpu_with_kstat
+            count
+          else
+            count_cpu_with_psrinfo
+          end
+        else
+          count_cpu_with_psrinfo
+        end
+      end
+
+      def get_physical_processor_count
+        if @major_version > 5 or (@major_version == 5 and @minor_version >= 8)
+          if output = Facter::Core::Execution.exec("/usr/sbin/psrinfo -p")
+            output.to_i
+          end
+        else
+          count_cpu_with_psrinfo
+        end
+      end
+
+      private
+
+      def count_cpu_with_kstat
+        if output = Facter::Core::Execution.exec("/usr/bin/kstat cpu_info")
+          output.scan(/\bcore_id\b\s+\d+/).uniq.length
+        else
+          nil
+        end
+      end
+
+      def count_cpu_with_psrinfo
+        if output = Facter::Core::Execution.exec("/usr/sbin/psrinfo")
+          output.split("\n").length
+        else
+          nil
+        end
+      end
+    end
+  end
+end