facter 2.0.1.rc1-x86-mingw32

data/lib/facter/osfamily.rb

@@ -0,0 +1,35 @@
+# Fact: osfamily
+#
+# Purpose: Returns the operating system
+#
+# Resolution:
+#   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
+#
+
+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 "Ubuntu", "Debian"
+      "Debian"
+    when "SLES", "SLED", "OpenSuSE", "SuSE"
+      "Suse"
+    when "Solaris", "Nexenta", "OmniOS", "OpenIndiana", "SmartOS"
+      "Solaris"
+    when "Gentoo"
+      "Gentoo"
+    when "Archlinux"
+      "Archlinux"
+    else
+      Facter.value("kernel")
+    end
+  end
+end

data/lib/facter/path.rb

@@ -0,0 +1,14 @@
+# Fact: path
+#
+# Purpose: Returns the $PATH variable.
+#
+# Resolution: Gets $PATH from the environment.
+#
+# Caveats:
+#
+
+Facter.add(:path) do
+  setcode do
+    ENV['PATH']
+  end
+end

data/lib/facter/physicalprocessorcount.rb

@@ -0,0 +1,84 @@
+# Fact: physicalprocessorcount
+#
+# 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.
+#
+# Caveats:
+#
+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
+  end
+end
+
+Facter.add('physicalprocessorcount') do
+  confine :kernel => :sunos
+
+  setcode do
+    # (#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.
+    kernelrelease = Facter.value(:kernelrelease)
+    (major_version, minor_version) = kernelrelease.split(".").map { |str| str.to_i }
+    cmd = "/usr/sbin/psrinfo"
+    result = nil
+    if (major_version > 5) or (major_version == 5 and minor_version >= 8) then
+      result = Facter::Core::Execution.exec("#{cmd} -p")
+    else
+      output = Facter::Core::Execution.exec(cmd)
+      result = output.split("\n").length.to_s
+    end
+  end
+end

data/lib/facter/processor.rb

@@ -0,0 +1,183 @@
+# Fact: processor
+#
+# Purpose:
+#   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 'uname -p' and the sysctl variable for 'hw.ncpu' for CPU
+#   count.
+#
+# Caveats:
+#
+
+# processor.rb
+#
+# Copyright (C) 2006 Mooter Media Ltd
+# Author: Matthew Palmer <matt@solutionsfirst.com.au>
+#
+
+require 'thread'
+require 'facter/util/processor'
+
+# 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
+    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
+  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("Processor") do
+  confine :kernel => :openbsd
+  setcode do
+    Facter::Core::Execution.exec("uname -p")
+  end
+end
+
+Facter.add("ProcessorCount") do
+  confine :kernel => :openbsd
+  setcode do
+    Facter::Core::Execution.exec("sysctl -n hw.ncpu")
+  end
+end
+
+Facter.add("ProcessorCount") do
+  confine :kernel => :Darwin
+  setcode do
+    Facter::Core::Execution.exec("sysctl -n hw.ncpu")
+  end
+end
+
+if Facter.value(:kernel) == "windows"
+  processor_list = []
+
+  Thread::exclusive do
+    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
+      else
+        processor_num = 1
+      end
+
+      processor_num.times do |i|
+        processor_list << proc.Name.squeeze(" ")
+      end
+    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
+    end
+  end
+end
+
+Facter.add("Processor") do
+  confine :kernel => [:dragonfly,:freebsd]
+  setcode do
+    Facter::Core::Execution.exec("sysctl -n hw.model")
+  end
+end
+
+Facter.add("ProcessorCount") do
+  confine :kernel => [:dragonfly,:freebsd]
+  setcode do
+    Facter::Core::Execution.exec("sysctl -n 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/ps.rb

@@ -0,0 +1,30 @@
+# Fact: ps
+#
+# Purpose: Internal fact for what to use to list all processes. Used by
+# Service{} type in Puppet.
+#
+# Resolution:
+#   Assumes "ps -ef" for all operating systems other than BSD derivatives, where
+#   it uses "ps auxwww"
+#
+# Caveats:
+#
+
+Facter.add(:ps) do
+  setcode do 'ps -ef' end
+end
+
+Facter.add(:ps) do
+  confine :operatingsystem => :OpenWrt
+  setcode do 'ps www' end
+end
+
+Facter.add(:ps) do
+  confine :operatingsystem => %w{FreeBSD NetBSD OpenBSD Darwin DragonFly}
+  setcode do 'ps auxwww' end
+end
+
+Facter.add(:ps) do
+  confine :operatingsystem => :windows
+  setcode do 'tasklist.exe' end
+end

data/lib/facter/puppetversion.rb

@@ -0,0 +1,20 @@
+# Fact: puppetversion
+#
+# Purpose: Return the version of puppet installed.
+#
+# Resolution:
+#   Requres puppet via Ruby and returns it's version constant.
+#
+# Caveats:
+#
+
+Facter.add(:puppetversion) do
+  setcode do
+    begin
+      require 'puppet'
+      Puppet::PUPPETVERSION.to_s
+    rescue LoadError
+      nil
+    end
+  end
+end

data/lib/facter/rubysitedir.rb

@@ -0,0 +1,12 @@
+# Fact: rubysitedir
+#
+# Purpose: Returns Ruby's site library directory.
+#
+
+require 'rbconfig'
+
+Facter.add :rubysitedir do
+  setcode do
+    RbConfig::CONFIG["sitelibdir"]
+  end
+end

data/lib/facter/rubyversion.rb

@@ -0,0 +1,12 @@
+# Fact: rubyversion
+#
+# Purpose: Returns the version of Ruby facter is running under.
+#
+# Resolution: Returns RUBY_VERSION.
+#
+# Caveats:
+#
+
+Facter.add(:rubyversion) do
+  setcode { RUBY_VERSION.to_s }
+end

data/lib/facter/selinux.rb

@@ -0,0 +1,99 @@
+# Fact: selinux
+#
+# Purpose:
+#
+# Resolution:
+#
+# Caveats:
+#
+
+# Fact for SElinux
+# Written by immerda admin team (admin(at)immerda.ch)
+
+sestatus_cmd = '/usr/sbin/sestatus'
+
+# This supports the fact that the selinux mount point is not always in the
+# same location -- the selinux mount point is operating system specific.
+def selinux_mount_point
+  path = "/selinux"
+  if FileTest.exists?('/proc/self/mounts')
+    # Centos 5 shows an error in which having ruby use File.read to read
+    # /proc/self/mounts combined with the puppet agent run with --listen causes
+    # a hang. Reading from other parts of /proc does not seem to cause this problem.
+    # The work around is to read the file in another process.
+    # -- andy Fri Aug 31 2012
+    selinux_line = Facter::Core::Execution.exec('cat /proc/self/mounts').each_line.find { |line| line =~ /selinuxfs/ }
+    if selinux_line
+      path = selinux_line.split[1]
+    end
+  end
+  path
+end
+
+Facter.add("selinux") do
+  confine :kernel => :linux
+  setcode do
+    result = "false"
+    if FileTest.exists?("#{selinux_mount_point}/enforce")
+      if FileTest.exists?("/proc/self/attr/current")
+        if (File.read("/proc/self/attr/current") != "kernel\0")
+          result = "true"
+        end
+      end
+    end
+    result
+  end
+end
+
+Facter.add("selinux_enforced") do
+  confine :selinux => :true
+  setcode do
+    result = "false"
+    if FileTest.exists?("#{selinux_mount_point}/enforce") and
+       File.read("#{selinux_mount_point}/enforce") =~ /1/i
+      result = "true"
+    end
+    result
+  end
+end
+
+Facter.add("selinux_policyversion") do
+  confine :selinux => :true
+  setcode do
+    result = 'unknown'
+    if FileTest.exists?("#{selinux_mount_point}/policyvers")
+      result = File.read("#{selinux_mount_point}/policyvers").chomp
+    end
+    result
+  end
+end
+
+Facter.add("selinux_current_mode") do
+  confine :selinux => :true
+  setcode do
+    result = 'unknown'
+    mode = Facter::Core::Execution.exec(sestatus_cmd)
+    mode.each_line { |l| result = $1 if l =~ /^Current mode\:\s+(\w+)$/i }
+    result.chomp
+  end
+end
+
+Facter.add("selinux_config_mode") do
+  confine :selinux => :true
+  setcode do
+    result = 'unknown'
+    mode = Facter::Core::Execution.exec(sestatus_cmd)
+    mode.each_line { |l| result = $1 if l =~ /^Mode from config file\:\s+(\w+)$/i }
+    result.chomp
+  end
+end
+
+Facter.add("selinux_config_policy") do
+  confine :selinux => :true
+  setcode do
+    result = 'unknown'
+    mode = Facter::Core::Execution.exec(sestatus_cmd)
+    mode.each_line { |l| result = $1 if l =~ /^Policy from config file\:\s+(\w+)$/i }
+    result.chomp
+  end
+end