facter 1.3.8 → 1.5

data/lib/facter/util/loader.rb

@@ -0,0 +1,96 @@
+require 'facter'
+
+# Load facts on demand.
+class Facter::Util::Loader
+    # Load all resolutions for a single fact.
+    def load(fact)
+        # Now load from the search path
+        shortname = fact.to_s.downcase
+        load_env(shortname)
+
+        filename = shortname + ".rb"
+        search_path.each do |dir|
+            # Load individual files
+            file = File.join(dir, filename)
+
+            load_file(file) if FileTest.exist?(file)
+
+            # And load any directories matching the name
+            factdir = File.join(dir, shortname)
+            load_dir(factdir) if FileTest.directory?(factdir)
+        end
+    end
+
+    # Load all facts from all directories.
+    def load_all
+        return if defined?(@loaded_all)
+
+        load_env
+
+        search_path.each do |dir|
+            next unless FileTest.directory?(dir)
+
+            Dir.entries(dir).each do |file|
+                path = File.join(dir, file)
+                if File.directory?(path)
+                    load_dir(path)
+                elsif file =~ /\.rb$/
+                    load_file(File.join(dir, file))
+                end
+            end
+        end
+
+        @loaded_all = true
+    end
+
+    # The list of directories we're going to search through for facts.
+    def search_path
+        result = []
+        result += $LOAD_PATH.collect { |d| File.join(d, "facter") }
+        if ENV.include?("FACTERLIB")
+            result += ENV["FACTERLIB"].split(":")
+        end
+
+        # This allows others to register additional paths we should search.
+        result += Facter.search_path
+
+        result
+    end
+
+    private
+
+    def load_dir(dir)
+        return if dir =~ /\/\.+$/ or dir =~ /\/util$/ or dir =~ /\/lib$/
+
+        Dir.entries(dir).find_all { |f| f =~ /\.rb$/ }.each do |file|
+            load_file(File.join(dir, file))
+        end
+    end
+
+    def load_file(file)
+        # We have to specify Kernel.load, because we have a load method.
+        Kernel.load(file)
+    end
+
+    # Load facts from the environment.  If no name is provided,
+    # all will be loaded.
+    def load_env(fact = nil)
+        # Load from the environment, if possible
+        ENV.each do |name, value|
+            # Skip anything that doesn't match our regex.
+            next unless name =~ /^facter_?(\w+)$/i
+            env_name = $1
+
+            # If a fact name was specified, skip anything that doesn't
+            # match it.
+            next if fact and env_name != fact
+
+            Facter.add($1) do
+                setcode { value }
+            end
+
+            # Short-cut, if we are only looking for one value.
+            break if fact
+        end
+    end
+end

data/lib/facter/util/macosx.rb

@@ -0,0 +1,50 @@
+## macosx.rb
+## Support methods for Apple OSX facts
+##
+## Copyright (C) 2007 Jeff McCune
+## Author: Jeff McCune <jeff.mccune@northstarlabs.net>
+##
+## 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
+##
+
+module Facter::Macosx
+  require 'thread'
+  require 'facter/util/plist'
+
+  # JJM I'd really like to dynamically generate these methods
+  # by looking at the _name key of the _items dict for each _dataType
+
+  def self.hardware_overview
+    # JJM Perhaps we should cache the XML data in a "class" level object.
+    top_level_plist = Plist::parse_xml %x{/usr/sbin/system_profiler -xml SPHardwareDataType}
+    system_hardware = top_level_plist[0]['_items'][0]
+    system_hardware.delete '_name'
+    system_hardware
+  end
+
+  # SPSoftwareDataType
+  def self.os_overview
+    top_level_plist = Plist::parse_xml %x{/usr/sbin/system_profiler -xml SPSoftwareDataType}
+    os_stuff = top_level_plist[0]['_items'][0]
+    os_stuff.delete '_name'
+    os_stuff
+  end
+
+  def self.sw_vers
+    ver = Hash.new
+    [ "productName", "productVersion", "buildVersion" ].each do |option|
+      ver["macosx_#{option}"] = %x{sw_vers -#{option}}.strip
+    end
+    ver
+  end
+end
+

data/lib/facter/util/manufacturer.rb

@@ -0,0 +1,39 @@
+# mamufacturer.rb
+# Support methods for manufacturer specific facts
+
+module Facter::Manufacturer
+	def self.dmi_find_system_info(name)
+		case Facter.value(:kernel)
+			when 'Linux'
+				return nil unless FileTest.exists?("/usr/sbin/dmidecode")
+		
+				output=%x{/usr/sbin/dmidecode 2>/dev/null}
+			when 'OpenBSD', 'FreeBSD'
+				return nil unless FileTest.exists?("/usr/local/sbin/dmidecode")
+		
+				output=%x{/usr/local/sbin/dmidecode 2>/dev/null}
+			when 'NetBSD'
+				return nil unless FileTest.exists?("/usr/pkg/sbin/dmidecode")
+
+				output=%x{/usr/pkg/sbin/dmidecode 2>/dev/null}
+            else
+                return
+		end
+		name.each_pair do |key,v|
+			v.each do |value|
+				output.split("Handle").each do |line|
+					if line =~ /#{key}/  and line =~ /#{value} (\w.*)\n*./
+						result = $1
+						Facter.add(value.chomp(':').gsub(' ','')) do
+							confine :kernel => [ :linux, :freebsd, :netbsd, :openbsd ]
+							setcode do
+							    result
+						        end
+					        end
+				        end
+			        end
+		        end
+	        end
+        end
+end
+

data/lib/facter/util/memory.rb

@@ -0,0 +1,54 @@
+## memory.rb
+## Support module for memory related facts
+##
+## 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
+##
+
+module Facter::Memory
+    require 'thread'
+
+    def self.meminfo_number(tag)
+        memsize = ""
+        Thread::exclusive do
+            size, scale = [0, ""]
+            File.readlines("/proc/meminfo").each do |l|
+                size, scale = [$1.to_f, $2] if l =~ /^#{tag}:\s+(\d+)\s+(\S+)/
+                # MemoryFree == memfree + cached + buffers
+                #  (assume scales are all the same as memfree)
+                if tag == "MemFree" &&
+                    l =~ /^(?:Buffers|Cached):\s+(\d+)\s+(?:\S+)/
+                    size += $1.to_f
+                end
+            end
+            memsize = scale_number(size, scale)
+        end
+
+        memsize
+    end
+
+    def self.scale_number(size, multiplier)
+        suffixes = ['', 'kB', 'MB', 'GB', 'TB']
+
+        s = suffixes.shift
+        while s != multiplier
+            s = suffixes.shift
+        end
+
+        while size > 1024.0
+            size /= 1024.0
+            s = suffixes.shift
+        end
+
+        return "%.2f %s" % [size, s]
+    end
+end
+

data/lib/facter/util/netmask.rb

@@ -0,0 +1,36 @@
+module Facter::NetMask
+
+def self.get_netmask
+        netmask = nil;
+        ipregex = %r{(\d{1,3}\.){3}\d{1,3}}
+
+        ops = nil
+        case Facter.value(:kernel)
+                when 'Linux'
+                        ops = {
+                                :ifconfig => '/sbin/ifconfig',
+                                :regex => %r{\s+ inet\saddr: #{Facter.ipaddress} .*? Mask: (#{ipregex})}x,
+                                :munge => nil,
+                        }
+                when 'SunOS'
+                        ops = {
+                                :ifconfig => '/usr/sbin/ifconfig -a',
+                                :regex => %r{\s+ inet\s+? #{Facter.ipaddress} \+? mask (\w{8})}x,
+                                :munge => Proc.new { |mask| mask.scan(/../).collect do |byte| byte.to_i(16) end.join('.') }
+                        }
+        end
+
+        %x{#{ops[:ifconfig]}}.split(/\n/).collect do |line|
+                matches = line.match(ops[:regex])
+                if !matches.nil?
+                        if ops[:munge].nil?
+                                netmask = matches[1]
+                        else
+                                netmask = ops[:munge].call(matches[1])
+                        end
+                end
+        end
+        netmask
+end
+
+end

data/lib/facter/util/resolution.rb

@@ -0,0 +1,125 @@
+# An actual fact resolution mechanism.  These are largely just chunks of
+# code, with optional confinements restricting the mechanisms to only working on
+# specific systems.  Note that the confinements are always ANDed, so any
+# confinements specified must all be true for the resolution to be
+# suitable.
+require 'facter/util/confine'
+
+require 'timeout'
+
+class Facter::Util::Resolution
+    attr_accessor :interpreter, :code, :name, :timeout
+
+    def self.have_which
+        if ! defined?(@have_which) or @have_which.nil?
+            %x{which which 2>/dev/null}
+            @have_which = ($? == 0)
+        end
+        @have_which
+    end
+
+    # Execute a chunk of code.
+    def self.exec(code, interpreter = "/bin/sh")
+        raise ArgumentError, "non-sh interpreters are not currently supported" unless interpreter == "/bin/sh"
+        binary = code.split(/\s+/).shift
+
+        if have_which
+            path = nil
+            if binary !~ /^\//
+                path = %x{which #{binary} 2>/dev/null}.chomp
+                # we don't have the binary necessary
+                return nil if path == ""
+            else
+                path = binary
+            end
+
+            return nil unless FileTest.exists?(path)
+        end
+
+        out = nil
+        begin
+            out = %x{#{code}}.chomp
+        rescue => detail
+            $stderr.puts detail
+            return nil
+        end
+        if out == ""
+            return nil
+        else
+            return out
+        end
+    end
+
+    # Add a new confine to the resolution mechanism.
+    def confine(confines)
+        confines.each do |fact, values|
+            @confines.push Facter::Util::Confine.new(fact, *values)
+        end
+    end
+
+    # Create a new resolution mechanism.
+    def initialize(name)
+        @name = name
+        @confines = []
+        @value = nil
+        @timeout = 0.5
+    end
+
+    # Return the number of confines.
+    def length
+        @confines.length
+    end
+
+    # We need this as a getter for 'timeout', because some versions
+    # of ruby seem to already have a 'timeout' method and we can't
+    # seem to override the instance methods, somehow.
+    def limit
+        @timeout
+    end
+
+    # Set our code for returning a value.
+    def setcode(string = nil, interp = nil, &block)
+        if string
+            @code = string
+            @interpreter = interp || "/bin/sh"
+        else
+            unless block_given?
+                raise ArgumentError, "You must pass either code or a block"
+            end
+            @code = block
+        end
+    end
+
+    # Is this resolution mechanism suitable on the system in question?
+    def suitable?
+        unless defined? @suitable
+            @suitable = ! @confines.detect { |confine| ! confine.true? }
+        end
+
+        return @suitable
+    end
+
+    def to_s
+        return self.value()
+    end
+
+    # How we get a value for our resolution mechanism.
+    def value
+        result = nil
+        begin
+            Timeout.timeout(limit) do
+                if @code.is_a?(Proc)
+                    result = @code.call()
+                else
+                    result = Facter::Util::Resolution.exec(@code,@interpreter)
+                end
+            end
+        rescue Timeout::Error => detail
+            warn "Timed out seeking value for %s" % self.name
+            return nil
+        end
+
+        return nil if result == ""
+        return result
+    end
+end

metadata

@@ -1,33 +1,26 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: facter
 version: !ruby/object:Gem::Version 
-  version: 1.3.8
-date: 2007-09-24 00:00:00 +02:00
-summary: Facter collects Operating system facts.
-require_paths: 
-- lib
-email: dev@reductivelabs.com
-homepage: http://reductivelabs.com/projects/facter
-rubyforge_project: facter
-description: Facter is a module for collecting simple facts about a host  Operating system.
-autorequire: 
-default_executable: facter
-bindir: bin
-has_rdoc: false
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: "1.5"
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
-- 
+- Luke Kanies
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-08 00:00:00 +02:00
+default_executable: facter
+dependencies: []
+
+description: Facter is a module for collecting simple facts about a host  Operating system.
+email: dev@reductivelabs.com
+executables: 
+- facter
+extensions: []
+
+extra_rdoc_files: []
+
 files: 
 - install.rb
 - COPYING
@@ -39,26 +32,75 @@ files:
 - CHANGELOG
 - bin/facter
 - lib/facter.rb
+- lib/facter/lsb.rb
 - lib/facter/processor.rb
+- lib/facter/id.rb
+- lib/facter/operatingsystem.rb
+- lib/facter/architecture.rb
+- lib/facter/operatingsystemrelease.rb
+- lib/facter/domain.rb
+- lib/facter/uniqueid.rb
 - lib/facter/memory.rb
+- lib/facter/hardwareisa.rb
+- lib/facter/facterversion.rb
+- lib/facter/ps.rb
+- lib/facter/rubysitedir.rb
+- lib/facter/hostname.rb
+- lib/facter/iphostnumber.rb
+- lib/facter/rubyversion.rb
+- lib/facter/Cfkey.rb
+- lib/facter/lsbmajdistrelease.rb
+- lib/facter/hardwaremodel.rb
+- lib/facter/macaddress.rb
+- lib/facter/util/resolution.rb
+- lib/facter/util/collection.rb
+- lib/facter/util/confine.rb
+- lib/facter/util/loader.rb
+- lib/facter/util/memory.rb
+- lib/facter/util/fact.rb
 - lib/facter/util/plist.rb
+- lib/facter/util/macosx.rb
+- lib/facter/util/ip.rb
 - lib/facter/util/plist/parser.rb
 - lib/facter/util/plist/generator.rb
+- lib/facter/util/manufacturer.rb
+- lib/facter/util/netmask.rb
+- lib/facter/fqdn.rb
+- lib/facter/ssh.rb
+- lib/facter/ipaddress.rb
+- lib/facter/puppetversion.rb
 - lib/facter/macosx.rb
+- lib/facter/kernelrelease.rb
 - lib/facter/manufacturer.rb
+- lib/facter/kernel.rb
 - lib/facter/ipmess.rb
+- lib/facter/netmask.rb
 - etc/facter.conf
-test_files: []
-
+has_rdoc: false
+homepage: http://reductivelabs.com/projects/facter
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: []
-
-executables: 
-- facter
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: facter
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Facter collects Operating system facts.
+test_files: []