facter 1.6.1 → 1.6.2

data/lib/facter/processor.rb

@@ -19,90 +19,87 @@
 #
 
 require 'thread'
-
-if ["Linux", "GNU/kFreeBSD"].include? Facter.value(:kernel)
-    processor_num = -1
-    processor_list = []
-    Thread::exclusive do
-        File.readlines("/proc/cpuinfo").each do |l|
-            if l =~ /processor\s+:\s+(\d+)/
-                processor_num = $1.to_i
-            elsif l =~ /model name\s+:\s+(.*)\s*$/
-                processor_list[processor_num] = $1 unless processor_num == -1
-                processor_num = -1
-            elsif l =~ /processor\s+(\d+):\s+(.*)/
-                processor_num = $1.to_i
-                processor_list[processor_num] = $2 unless processor_num == -1
-            end
-        end
+require 'facter/util/processor'
+
+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
-            processor_list.length.to_s
-        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
 
-    processor_list.each_with_index do |desc, i|
-        Facter.add("Processor#{i}") do
-            confine :kernel => [ :linux, :"gnu/kfreebsd" ]
-            setcode do
-                desc
-            end
-        end
-    end
+Facter.add("ProcessorCount") do
+  confine :kernel => :aix
+  setcode do
+    processor_list = Facter::Util::Processor.enum_lsdev
+        
+    processor_list.length.to_s
+  end
 end
 
-if Facter.value(:kernel) == "AIX"
-    processor_num = -1
-    processor_list = {}
-    Thread::exclusive do
-        procs = Facter::Util::Resolution.exec('lsdev -Cc processor')
-        procs.each do |proc|
-            if proc =~ /^proc(\d+)/
-                processor_num = $1.to_i
-                # Not retrieving the frequency since AIX 4.3.3 doesn't support the
-                # attribute and some people still use the OS.
-                proctype = Facter::Util::Resolution.exec('lsattr -El proc0 -a type')
-                if proctype =~ /^type\s+(\S+)\s+/
-                    processor_list["processor#{processor_num}"] = $1
-                end
-            end
-        end
-    end
+Facter.add("Processor") do
+  confine :kernel => :openbsd
+  setcode do
+    Facter::Util::Resolution.exec("uname -p")
+  end
+end
 
-    Facter.add("ProcessorCount") do
-        confine :kernel => :aix
-        setcode do
-            processor_list.length.to_s
-        end
-    end
+Facter.add("ProcessorCount") do
+  confine :kernel => :openbsd
+  setcode do
+    Facter::Util::Resolution.exec("sysctl -n hw.ncpu")
+  end
+end
 
-    processor_list.each do |proc, desc|
-        Facter.add(proc) do
-            confine :kernel => :aix
-            setcode do
-                desc
-            end
-        end
-    end
+Facter.add("ProcessorCount") do
+  confine :kernel => :Darwin
+  setcode do
+    Facter::Util::Resolution.exec("sysctl -n hw.ncpu")
+  end
 end
 
-if Facter.value(:kernel) == "OpenBSD"
-    Facter.add("Processor") do
-        confine :kernel => :openbsd
-        setcode do
-            Facter::Util::Resolution.exec("uname -p")
-        end
-    end
+## 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 = Facter::Util::Processor.enum_cpuinfo
+processor_list_aix = Facter::Util::Processor.enum_lsdev
 
-    Facter.add("ProcessorCount") do
-        confine :kernel => :openbsd
-        setcode do
-            Facter::Util::Resolution.exec("sysctl hw.ncpu | cut -d'=' -f2")
-        end
+if processor_list.length != 0
+  processor_list.each_with_index do |desc, i|
+    Facter.add("Processor#{i}") do
+      confine :kernel => [ :linux, :"gnu/kfreebsd" ]
+      setcode do
+        desc
+      end
     end
+  end
+elsif processor_list_aix.length != 0
+  processor_list_aix.each_with_index do |desc, i|
+    Facter.add("Processor#{i}") do
+      confine :kernel => [ :aix ]
+      setcode do
+        desc
+      end
+    end
+  end
 end
 
 if Facter.value(:kernel) == "windows"
@@ -142,3 +139,25 @@ if Facter.value(:kernel) == "windows"
     end
   end
 end
+
+Facter.add("Processor") do
+  confine :kernel => :dragonfly
+  setcode do
+    Facter::Util::Resolution.exec("sysctl -n hw.model")
+  end
+end
+
+Facter.add("ProcessorCount") do
+  confine :kernel => :dragonfly
+  setcode do
+    Facter::Util::Resolution.exec("sysctl -n hw.ncpu")
+  end
+end
+
+Facter.add("processorcount") do
+  confine :kernel => :sunos
+  setcode do
+    kstat = Facter::Util::Resolution.exec("/usr/bin/kstat cpu_info")
+    kstat.scan(/\bcore_id\b\s+\d+/).uniq.length
+  end
+end

data/lib/facter/ps.rb

@@ -11,12 +11,12 @@
 #
 
 Facter.add(:ps) do
-    setcode do 'ps -ef' end
+  setcode do 'ps -ef' end
 end
 
 Facter.add(:ps) do
-    confine :operatingsystem => %w{FreeBSD NetBSD OpenBSD Darwin}
-    setcode do 'ps auxwww' end
+  confine :operatingsystem => %w{FreeBSD NetBSD OpenBSD Darwin DragonFly}
+  setcode do 'ps auxwww' end
 end
 
 Facter.add(:ps) do

data/lib/facter/puppetversion.rb

@@ -9,12 +9,12 @@
 #
 
 Facter.add(:puppetversion) do
-    setcode do
-        begin
-            require 'puppet'
-            Puppet::PUPPETVERSION.to_s
-        rescue LoadError
-            nil
-        end
+  setcode do
+    begin
+      require 'puppet'
+      Puppet::PUPPETVERSION.to_s
+    rescue LoadError
+      nil
     end
+  end
 end

data/lib/facter/rubysitedir.rb

@@ -9,10 +9,10 @@
 #
 
 Facter.add :rubysitedir do
-    setcode do
-        version = RUBY_VERSION.to_s.sub(/\.\d+$/, '')
-        $:.find do |dir|
-            dir =~ /#{File.join("site_ruby", version)}$/
-        end
+  setcode do
+    version = RUBY_VERSION.to_s.sub(/\.\d+$/, '')
+    $:.find do |dir|
+      dir =~ /#{File.join("site_ruby", version)}$/
     end
+  end
 end

data/lib/facter/rubyversion.rb

@@ -8,5 +8,5 @@
 #
 
 Facter.add(:rubyversion) do
-    setcode { RUBY_VERSION.to_s }
+  setcode { RUBY_VERSION.to_s }
 end

data/lib/facter/ssh.rb

@@ -12,20 +12,20 @@
 ##
 
 ["/etc/ssh","/usr/local/etc/ssh","/etc","/usr/local/etc"].each do |dir|
-    {"SSHDSAKey" => "ssh_host_dsa_key.pub", "SSHRSAKey" => "ssh_host_rsa_key.pub"}.each do |name,file|
-        Facter.add(name) do
-            setcode do
-                value = nil
-                filepath = File.join(dir,file)
-                if FileTest.file?(filepath)
-                    begin
-                        File.open(filepath) { |f| value = f.read.chomp.split(/\s+/)[1] }
-                    rescue
-                        value = nil
-                    end
-                end
-                value
-            end # end of proc
-        end # end of add
-    end # end of hash each
+  {"SSHDSAKey" => "ssh_host_dsa_key.pub", "SSHRSAKey" => "ssh_host_rsa_key.pub", "SSHECDSAKey" => "ssh_host_ecdsa_key.pub"}.each do |name,file|
+    Facter.add(name) do
+      setcode do
+        value = nil
+        filepath = File.join(dir,file)
+        if FileTest.file?(filepath)
+          begin
+            File.open(filepath) { |f| value = f.read.chomp.split(/\s+/)[1] }
+          rescue
+            value = nil
+          end
+        end
+        value
+      end # end of proc
+    end # end of add
+  end # end of hash each
 end # end of dir each

data/lib/facter/timezone.rb

@@ -8,7 +8,7 @@
 #
 
 Facter.add("timezone") do
-     setcode do
-         Time.new.zone
-     end
+  setcode do
+    Time.new.zone
+  end
 end

data/lib/facter/uniqueid.rb

@@ -1,4 +1,4 @@
 Facter.add(:uniqueid) do
-    setcode 'hostid'
-    confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS Scientific SLC SuSE SLES Debian Ubuntu Gentoo AIX OEL OracleLinux OVS GNU/kFreeBSD}
+  setcode 'hostid'
+  confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS Scientific SLC SuSE SLES Debian Ubuntu Gentoo AIX OEL OracleLinux OVS GNU/kFreeBSD}
 end

data/lib/facter/util/collection.rb

@@ -5,126 +5,126 @@ require 'facter/util/loader'
 # Manage which facts exist and how we access them.  Largely just a wrapper
 # around a hash of facts.
 class Facter::Util::Collection
-    # Return a fact object by name.  If you use this, you still have to call
-    # 'value' on it to retrieve the actual value.
-    def [](name)
-        value(name)
-    end
-
-    # Add a resolution mechanism for a named fact.  This does not distinguish
-    # between adding a new fact and adding a new way to resolve a fact.
-    def add(name, options = {}, &block)
-        name = canonize(name)
+  # Return a fact object by name.  If you use this, you still have to call
+  # 'value' on it to retrieve the actual value.
+  def [](name)
+    value(name)
+  end
 
-        unless fact = @facts[name]
-            fact = Facter::Util::Fact.new(name)
+  # Add a resolution mechanism for a named fact.  This does not distinguish
+  # between adding a new fact and adding a new way to resolve a fact.
+  def add(name, options = {}, &block)
+    name = canonize(name)
 
-            @facts[name] = fact
-        end
+    unless fact = @facts[name]
+      fact = Facter::Util::Fact.new(name)
 
-        # Set any fact-appropriate options.
-        options.each do |opt, value|
-            method = opt.to_s + "="
-            if fact.respond_to?(method)
-                fact.send(method, value)
-                options.delete(opt)
-            end
-        end
+      @facts[name] = fact
+    end
 
-        if block
-            resolve = fact.add(&block)
-            # Set any resolve-appropriate options
-            options.each do |opt, value|
-                method = opt.to_s + "="
-                if resolve.respond_to?(method)
-                    resolve.send(method, value)
-                    options.delete(opt)
-                end
-            end
-        end
+    # Set any fact-appropriate options.
+    options.each do |opt, value|
+      method = opt.to_s + "="
+      if fact.respond_to?(method)
+        fact.send(method, value)
+        options.delete(opt)
+      end
+    end
 
-        unless options.empty?
-            raise ArgumentError, "Invalid facter option(s) %s" % options.keys.collect { |k| k.to_s }.join(",")
+    if block
+      resolve = fact.add(&block)
+      # Set any resolve-appropriate options
+      options.each do |opt, value|
+        method = opt.to_s + "="
+        if resolve.respond_to?(method)
+          resolve.send(method, value)
+          options.delete(opt)
         end
+      end
+    end
 
-        return fact
+    unless options.empty?
+      raise ArgumentError, "Invalid facter option(s) %s" % options.keys.collect { |k| k.to_s }.join(",")
     end
 
-    include Enumerable
+    return fact
+  end
 
-    # Iterate across all of the facts.
-    def each
-        @facts.each do |name, fact|
-            value = fact.value
-            unless value.nil?
-                yield name.to_s, value
-            end
-        end
+  include Enumerable
+
+  # Iterate across all of the facts.
+  def each
+    @facts.each do |name, fact|
+      value = fact.value
+      unless value.nil?
+        yield name.to_s, value
+      end
     end
+  end
 
-    # Return a fact by name.
-    def fact(name)
-        name = canonize(name)
+  # Return a fact by name.
+  def fact(name)
+    name = canonize(name)
 
-        # Try to load the fact if necessary
-        loader.load(name) unless @facts[name]
+    # Try to load the fact if necessary
+    loader.load(name) unless @facts[name]
 
-        # Try HARDER
-        loader.load_all unless @facts[name]
+    # Try HARDER
+    loader.load_all unless @facts[name]
 
-        @facts[name]
-    end
+    @facts[name]
+  end
 
-    # Flush all cached values.
-    def flush
-        @facts.each { |name, fact| fact.flush }
-    end
+  # Flush all cached values.
+  def flush
+    @facts.each { |name, fact| fact.flush }
+  end
 
-    def initialize
-        @facts = Hash.new
-    end
+  def initialize
+    @facts = Hash.new
+  end
 
-    # Return a list of all of the facts.
-    def list
-        return @facts.keys
-    end
+  # Return a list of all of the facts.
+  def list
+    return @facts.keys
+  end
 
-    # Load all known facts.
-    def load_all
-        loader.load_all
-    end
+  # Load all known facts.
+  def load_all
+    loader.load_all
+  end
 
-    # The thing that loads facts if we don't have them.
-    def loader
-        unless defined?(@loader)
-            @loader = Facter::Util::Loader.new
-        end
-        @loader
+  # The thing that loads facts if we don't have them.
+  def loader
+    unless defined?(@loader)
+      @loader = Facter::Util::Loader.new
     end
-
-    # Return a hash of all of our facts.
-    def to_hash
-        @facts.inject({}) do |h, ary|
-            value = ary[1].value
-            if ! value.nil?
-                # For backwards compatibility, convert the fact name to a string.
-                h[ary[0].to_s] = value
-            end
-            h
-        end
+    @loader
+  end
+
+  # Return a hash of all of our facts.
+  def to_hash
+    @facts.inject({}) do |h, ary|
+      value = ary[1].value
+      if ! value.nil?
+        # For backwards compatibility, convert the fact name to a string.
+        h[ary[0].to_s] = value
+      end
+      h
     end
+  end
 
-    def value(name)
-        if fact = fact(name)
-            fact.value
-        end
+  def value(name)
+    if fact = fact(name)
+      fact.value
     end
+  end
 
-    private
+  private
 
-    # Provide a consistent means of getting the exact same fact name
-    # every time.
-    def canonize(name)
-        name.to_s.downcase.to_sym
-    end
+  # Provide a consistent means of getting the exact same fact name
+  # every time.
+  def canonize(name)
+    name.to_s.downcase.to_sym
+  end
 end