bolt 0.20.0 → 0.20.2

data/vendored/facter/lib/facter/processors.rb

@@ -0,0 +1,66 @@
+# Fact: processors
+#
+# Purpose:
+#   Provide additional facts about the machine's CPUs, including:
+#   Models: A list of processors present on the system.
+#   Count:  The number of hardware threads.
+#   Physicalcount: The number of physical processors.
+#   Speed: The speed of the processors on the system.
+#
+#   This fact is structured. These values are returned as a group of key-value pairs.
+#
+# Resolution:
+#   Linux and kFreeBSD parse `/proc/cpuinfo` for each processor.
+#   AIX parses the output of `lsdev` for its processor section.
+#   Solaris parses 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.
+#
+# Caveats:
+#   The 'speed' sub-fact is not currently supported on all platforms.
+
+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/vendored/facter/lib/facter/processors/os.rb

@@ -0,0 +1,244 @@
+# 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.ole_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 2>/dev/null")
+        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
+
+      def get_processor_speed
+        speed = Facter::Util::POSIX.sysctl("hw.cpuspeed").to_i
+        if speed < 1000
+          "#{speed} MHz"
+        else
+          speed = speed.to_f / 1000
+          "#{(speed * 100).round.to_f / 100.0} GHz"
+        end
+      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

data/vendored/facter/lib/facter/ps.rb

@@ -0,0 +1,31 @@
+# Fact: ps
+#
+# Purpose: 
+#   Internal fact for what to use to list all processes. Used by
+#   the 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/vendored/facter/lib/facter/puppetversion.rb

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

data/vendored/facter/lib/facter/rackspace.rb

@@ -0,0 +1,37 @@
+# Fact: rsc_<RACKSPACE INSTANCE DATA>
+#
+# Purpose: Determine information about Rackspace cloud instances.
+#
+# Resolution:
+#   If this is a Rackspace Cloud instance, populates `rsc_` facts: `is_rsc`, `rsc_region`,
+#   and `rsc_instance_id`.
+#
+# Caveats:
+#   Depends on Xenstore.
+#
+
+Facter.add(:is_rsc) do
+  setcode do
+    result = Facter::Util::Resolution.exec("/usr/bin/xenstore-read vm-data/provider_data/provider 2> /dev/null")
+    if result == "Rackspace"
+      "true"
+    end
+  end
+end
+
+Facter.add(:rsc_region) do
+  confine :is_rsc => "true"
+  setcode do
+    Facter::Util::Resolution.exec("/usr/bin/xenstore-read vm-data/provider_data/region 2> /dev/null")
+  end
+end
+
+Facter.add(:rsc_instance_id) do
+  confine :is_rsc => "true"
+  setcode do
+    result = Facter::Util::Resolution.exec("/usr/bin/xenstore-read name")
+    if result and (match = result.match(/instance-(.*)/))
+      match[1]
+    end
+  end
+end

data/vendored/facter/lib/facter/rubyplatform.rb

@@ -0,0 +1,12 @@
+# Fact: rubyplatform
+#
+# Purpose: Returns the platform of Ruby that facter is running under.
+#
+# Resolution: Returns the value of the `RUBY_PLATFORM` constant.
+#
+# Caveats:
+#
+
+Facter.add(:rubyplatform) do
+  setcode { RUBY_PLATFORM.to_s }
+end

data/vendored/facter/lib/facter/rubysitedir.rb

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

data/vendored/facter/lib/facter/rubyversion.rb

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

data/vendored/facter/lib/facter/selinux.rb

@@ -0,0 +1,154 @@
+# Fact: selinux
+#
+# Purpose:
+#   Determine whether SE Linux is enabled on the node.
+#
+# Resolution:
+#   Checks for the existence of the enforce file under the SE Linux mount
+#   point (e.g. `/selinux/enforce`) and returns true if `/proc/self/attr/current`
+#   does not contain the kernel.
+#
+# Caveats:
+#
+
+# Fact: selinux_config_mode
+#
+# Purpose:
+#   Returns the configured SE Linux mode (e.g., `enforcing`, `permissive`, or `disabled`).
+#
+# Resolution:
+#   Parses the output of `sestatus_cmd` and returns the value of the line beginning
+#   with `Mode from config file:`.
+#
+# Caveats:
+#
+
+# Fact: selinux_config_policy
+#
+# Purpose:
+#   Returns the configured SE Linux policy (e.g., `targeted`, `MLS`, or `minimum`).
+#
+# Resolution:
+#   Parses the output of `sestatus_cmd` and returns the value of the line beginning
+#   with `Policy from config file:`.
+#
+# Caveats:
+#
+
+# Fact: selinux_enforced
+#
+# Purpose:
+#   Returns whether SE Linux is enabled (`true`) or not (`false`).
+#
+# Resolution:
+#   Returns the value found in the `enforce` file under the SE Linux mount
+#   point (e.g. `/selinux/enforce`).
+#
+# Caveats:
+#
+
+# Fact: selinux_policyversion
+#
+# Purpose:
+#   Returns the current SE Linux policy version.
+#
+# Resolution:
+#   Reads the content of the `policyvers` file found under the SE Linux mount point,
+#   e.g. `/selinux/policyvers`.
+#
+# 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")
+        begin
+          if (File.read("/proc/self/attr/current") != "kernel\0")
+            result = true
+          end
+        rescue
+        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 = $2 if l =~ /^(Policy from config file|Loaded policy name)\:\s+(\w+)$/i }
+    result.chomp
+  end
+end