facter 1.3.8 → 1.5

data/lib/facter/processor.rb

@@ -1,26 +1,13 @@
-#
 # processor.rb
 # Additional Facts about the machine's CPUs
 #
 # Copyright (C) 2006 Mooter Media Ltd
 # Author: Matthew Palmer <matt@solutionsfirst.com.au>
 #
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation (version 2 of the License)
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston MA  02110-1301 USA
-#
 
 require 'thread'
 
-if Facter.kernel == "Linux"
+if Facter.value(:kernel) == "Linux"
     processor_num = -1
     processor_list = []
     Thread::exclusive do
@@ -50,3 +37,38 @@ if Facter.kernel == "Linux"
         end
     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("ProcessorCount") do
+        confine :kernel => :aix
+        setcode do
+            processor_list.length.to_s
+        end
+    end
+
+    processor_list.each do |proc, desc|
+        Facter.add(proc) do
+            confine :kernel => :aix
+            setcode do
+                desc
+            end
+        end
+    end
+end

data/lib/facter/ps.rb

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

data/lib/facter/puppetversion.rb

@@ -0,0 +1,10 @@
+Facter.add(:puppetversion, :timeout => 1.5) do
+    setcode {
+        begin
+            require 'puppet'
+            Puppet::PUPPETVERSION.to_s
+        rescue LoadError
+            nil
+        end
+    }
+end

data/lib/facter/rubysitedir.rb

@@ -0,0 +1,8 @@
+Facter.add :rubysitedir do
+    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

@@ -0,0 +1,3 @@
+Facter.add(:rubyversion) do
+    setcode { RUBY_VERSION.to_s }
+end

data/lib/facter/ssh.rb

@@ -0,0 +1,33 @@
+## ssh.rb
+## Facts related to SSH
+##
+## This program is free software; you can redistribute it and/or
+## modify it under the terms of the GNU General Public License
+## as published by the Free Software Foundation (version 2 of the License)
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+## You should have received a copy of the GNU General Public License
+## along with this program; if not, write to the Free Software
+## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston MA  02110-1301 USA
+##
+
+["/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
+end # end of dir each

data/lib/facter/uniqueid.rb

@@ -0,0 +1,4 @@
+Facter.add(:uniqueid) do
+    setcode 'hostid',  '/bin/sh'
+    confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS SuSE Debian Gentoo AIX}
+end

data/lib/facter/util/collection.rb

@@ -0,0 +1,126 @@
+require 'facter'
+require 'facter/util/fact'
+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)
+
+        unless fact = @facts[name]
+            fact = Facter::Util::Fact.new(name)
+
+            @facts[name] = fact
+        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
+
+        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
+
+        unless options.empty?
+            raise ArgumentError, "Invalid facter option(s) %s" % options.keys.collect { |k| k.to_s }.join(",")
+        end
+
+        return fact
+    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)
+
+        loader.load(name) unless @facts[name]
+
+        return @facts[name]
+    end
+
+    # Flush all cached values.
+    def flush
+        @facts.each { |name, fact| fact.flush }
+    end
+
+    def initialize
+        @facts = Hash.new
+    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
+
+    # The thing that loads facts if we don't have them.
+    def loader
+        unless defined?(@loader)
+            @loader = Facter::Util::Loader.new
+        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
+    end
+
+    private
+
+    # Provide a consistent means of getting the exact same fact name
+    # every time.
+    def canonize(name)
+        name.to_s.downcase.to_sym
+    end
+end

data/lib/facter/util/confine.rb

@@ -0,0 +1,41 @@
+# A restricting tag for fact resolution mechanisms.  The tag must be true
+# for the resolution mechanism to be suitable.
+class Facter::Util::Confine
+    attr_accessor :fact, :values
+
+    # Add the restriction.  Requires the fact name, an operator, and the value
+    # we're comparing to.
+    def initialize(fact, *values)
+        raise ArgumentError, "The fact name must be provided" unless fact
+        raise ArgumentError, "One or more values must be provided" if values.empty?
+        fact = fact.to_s if fact.is_a? Symbol
+        @fact = fact
+        @values = values.collect do |value|
+            if value.is_a? String
+                value
+            else
+                value.to_s
+            end
+        end
+    end
+
+    def to_s
+        return "'%s' '%s'" % [@fact, @values.join(",")]
+    end
+
+    # Evaluate the fact, returning true or false.
+    def true?
+        unless fact = Facter[@fact]
+            Facter.debug "No fact for %s" % @fact
+            return false
+        end
+        value = fact.value
+
+        return false if value.nil?
+
+        @values.each { |v|
+            return true if value.downcase == v.downcase
+        }
+        return false
+    end
+end

data/lib/facter/util/fact.rb

@@ -0,0 +1,122 @@
+require 'facter'
+require 'facter/util/resolution'
+
+class Facter::Util::Fact
+    TIMEOUT = 5
+
+    attr_accessor :name, :ldapname
+
+    # Create a new fact, with no resolution mechanisms.
+    def initialize(name, options = {})
+        @name = name.to_s.downcase.intern
+
+        # LAK:NOTE: This is slow for many options, but generally we won't have any and at
+        # worst we'll have one.  If we add more, this should be made more efficient.
+        options.each do |name, value|
+            case name
+            when :ldapname: self.ldapname = value
+            else
+                raise ArgumentError, "Invalid fact option '%s'" % name
+            end
+        end
+
+        @ldapname ||= @name.to_s
+
+        @resolves = []
+        @searching = false
+
+        @value = nil
+    end
+
+    # Add a new resolution mechanism.  This requires a block, which will then
+    # be evaluated in the context of the new mechanism.
+    def add(&block)
+        raise ArgumentError, "You must pass a block to Fact<instance>.add" unless block_given?
+
+        resolve = Facter::Util::Resolution.new(@name)
+
+        resolve.instance_eval(&block)
+
+        @resolves << resolve
+
+        # Immediately sort the resolutions, so that we always have
+        # a sorted list for looking up values.
+        #  We always want to look them up in the order of number of
+        # confines, so the most restricted resolution always wins.
+        @resolves.sort! { |a, b| b.length <=> a.length }
+
+        return resolve
+    end
+
+    # Flush any cached values.
+    def flush
+        @value = nil
+        @suitable = nil
+    end
+
+    # Return the value for a given fact.  Searches through all of the mechanisms
+    # and returns either the first value or nil.
+    def value
+        return @value if @value
+
+        if @resolves.length == 0
+            Facter.debug "No resolves for %s" % @name
+            return nil
+        end
+
+        searching do
+            @value = nil
+
+            foundsuits = false
+            @value = @resolves.inject(nil) { |result, resolve|
+                next unless resolve.suitable?
+                foundsuits = true
+
+                tmp = resolve.value
+
+                break tmp unless tmp.nil? or tmp == ""
+            }
+
+            unless foundsuits
+                Facter.debug "Found no suitable resolves of %s for %s" % [@resolves.length, @name]
+            end
+        end
+
+        if @value.nil?
+            # nothing
+            Facter.debug("value for %s is still nil" % @name)
+            return nil
+        else
+            return @value
+        end
+    end
+
+    private
+
+    # Are we in the midst of a search?
+    def searching?
+        @searching
+    end
+
+    # Lock our searching process, so we never ge stuck in recursion.
+    def searching
+        if searching?
+            Facter.debug "Caught recursion on %s" % @name
+            
+            # return a cached value if we've got it
+            if @value
+                return @value
+            else
+                return nil
+            end
+        end
+
+        # If we've gotten this far, we're not already searching, so go ahead and do so.
+        @searching = true
+        begin
+            yield
+        ensure
+            @searching = false
+        end
+    end
+end

data/lib/facter/util/ip.rb

@@ -0,0 +1,98 @@
+module Facter::IPAddress
+    
+    def self.get_interfaces
+    
+     int = nil
+    
+     case Facter.value(:kernel)
+        when 'Linux', 'OpenBSD', 'NetBSD', 'FreeBSD'
+           output = %x{/sbin/ifconfig -a}       
+        when 'SunOS'
+           output = %x{/usr/sbin/ifconfig -a} 
+     end
+    
+     # We get lots of warnings on platforms that don't get an output
+     # made.
+     if output
+         int = output.scan(/^\w+[.:]?\d+/)
+     else
+         []
+     end
+    
+    end
+    
+    def self.get_interface_value_nonbsd(interface, label)
+    
+    tmp1 = nil
+
+    case Facter.value(:kernel)
+      when 'Linux'
+       output_int = %x{/sbin/ifconfig #{interface}}
+       addr = /inet addr:([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+       mac  = /(?:ether|HWaddr)\s+(\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2})/
+       mask = /Mask:([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+     when 'OpenBSD', 'NetBSD', 'FreeBSD'
+       output_int = %x{/sbin/ifconfig #{interface}}
+       addr = /inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+       mac  = /(?:ether|lladdr)\s+(\w\w:\w\w:\w\w:\w\w:\w\w:\w\w)/
+       mask = /netmask\s+(\w{10})/
+    when 'SunOS'
+       output_int = %x{/usr/sbin/ifconfig #{interface}}
+       addr = /inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+       mac  = /(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/
+       mask = /netmask\s+(\w{8})/
+    end
+
+    case label
+      when 'ipaddress'
+       regex = addr
+      when 'macaddress'
+       regex = mac
+      when 'netmask'
+       regex = mask
+    end 
+     
+      if interface != "lo" && interface != "lo0"
+        output_int.each { |s|
+           tmp1 = $1 if s =~ regex
+       }
+      end
+
+      if tmp1 
+        value = tmp1
+      end
+
+   end
+
+   def self.get_interface_value_bsd(interface, label)
+
+    tmp1 = []
+
+    int_hash = {}
+    output_int = %x{/sbin/ifconfig #{interface}}
+    addr = /inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+    mac  = /(?:ether|lladdr)\s+(\w\w:\w\w:\w\w:\w\w:\w\w:\w\w)/
+    mask = /netmask\s+(\w{10})/
+
+    case label
+      when 'ipaddress'
+       regex = addr
+      when 'macaddress'
+       regex = mac
+      when 'netmask'
+       regex = mask
+    end
+
+    if interface != "lo" && interface != "lo0"
+      output_int.each { |s|
+        tmp1.push($1) if s =~ regex
+      }
+    end
+
+    if tmp1
+       value = tmp1.shift
+    end
+
+   end
+end
+