facter 1.0.1

data/TODO

@@ -0,0 +1,4 @@
+More documentation.
+
+The ability to specify fact names with strings or symbols; right now, only
+strings are supported

data/bin/facter

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby 
+
+#--------------------
+# duh, it's facter!
+#
+# $Id: facter,v 1.1.1.1 2004/03/21 21:06:27 luke Exp $
+
+require 'getoptlong'
+require 'facter'
+
+Facter.load
+
+$debug = 0
+
+config = nil
+
+result = GetoptLong.new(
+        [ "--version",         "-v",     GetoptLong::NO_ARGUMENT ],
+	[ "--help",		"-h",            GetoptLong::NO_ARGUMENT ],
+	[ "--debug",	"-d",            GetoptLong::NO_ARGUMENT ],
+	[ "--config",    "-c",           GetoptLong::REQUIRED_ARGUMENT ]
+)
+
+result.each { |opt,arg|
+    case opt
+        when "--version"
+            puts "%s" % Facter.version
+            exit
+        when "--debug"
+			Facter.debugging(1)
+        when "--help"
+            puts "There is no help yet"
+            exit
+        else
+            raise "Invalid option '#{opt}'"
+    end
+}
+
+names = []
+
+unless config.nil?
+	File.open(config) { |file|
+		names = file.readlines.collect { |line|
+			line.chomp
+		}
+	}
+end
+
+ARGV.each { |item|
+	names.push item
+}
+
+facts = {}
+
+if names.empty?
+    Facter.each { |name,fact|
+        facts[name] = fact
+    }
+else
+    names.each { |name|
+        begin
+            facts[name] = Facter[name].value
+        rescue => error
+            STDERR.puts "Could not retrieve %s: #{error}" % name
+            exit 10
+        end
+    }
+end
+
+facts.each { |name,value|
+	puts "%s => %s" % [name,value]
+}

data/etc/facter.conf

@@ -0,0 +1,5 @@
+Hostname
+OperatingSystem
+OperatingSystemRelease
+SSHDSAKey
+CfKey

data/install.rb

@@ -0,0 +1,289 @@
+#! /usr/bin/env ruby
+#--
+# Copyright 2004 Austin Ziegler <ruby-install@halostatue.ca>
+#   Install utility. Based on the original installation script for rdoc by the
+#   Pragmatic Programmers.
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later) or the Ruby licence.
+#
+# Usage
+# -----
+# In most cases, if you have a typical project layout, you will need to do
+# absolutely nothing to make this work for you. This layout is:
+#
+#   bin/    # executable files -- "commands"
+#   lib/    # the source of the library
+#   tests/  # unit tests
+#
+# The default behaviour:
+# 1) Run all unit test files (ending in .rb) found in all directories under
+#    tests/.
+# 2) Build Rdoc documentation from all files in bin/ (excluding .bat and .cmd),
+#    all .rb files in lib/, ./README, ./ChangeLog, and ./Install.
+# 3) Build ri documentation from all files in bin/ (excluding .bat and .cmd),
+#    and all .rb files in lib/. This is disabled by default on Win32.
+# 4) Install commands from bin/ into the Ruby bin directory. On Windows, if a
+#    if a corresponding batch file (.bat or .cmd) exists in the bin directory,
+#    it will be copied over as well. Otherwise, a batch file (always .bat) will
+#    be created to run the specified command.
+# 5) Install all library files ending in .rb from lib/ into Ruby's
+#    site_lib/version directory.
+#
+# $Id: install.rb,v 1.6 2004/08/08 20:33:09 austin Exp $
+#++
+
+require 'rbconfig'
+require 'find'
+require 'fileutils'
+require 'optparse'
+require 'ostruct'
+
+InstallOptions = OpenStruct.new
+
+$loadedrdoc = false
+
+begin
+    require 'rdoc/rdoc'
+    $loadedrdoc = true
+rescue LoadError => detail
+    $stderr.puts "Could not load rdoc/rdoc: %s" % detail
+    InstallOptions.rdoc = false
+end
+
+
+def glob(list)
+  g = list.map { |i| Dir.glob(i) }
+  g.flatten!
+  g.compact!
+  g.reject! { |e| e =~ /CVS/ }
+  g
+end
+
+  # Set these values to what you want installed.
+#bins  = glob(%w{bin/**/*}).reject { |e| e =~ /\.(bat|cmd)$/ }
+bins  = ["bin/facter"]
+rdoc  = glob(%w{bin/**/* lib/**/*.rb README CHANGELOG INSTALL}).reject { |e| e=~ /\.(bat|cmd)$/ }
+ri    = glob(%w(bin/**/* lib/**/*.rb)).reject { |e| e=~ /\.(bat|cmd)$/ }
+libs  = glob(%w{lib/**/*.rb})
+tests = glob(%w{tests/**/*.rb})
+
+def do_bins(bins, target, strip = 'bin/')
+  bins.each do |bf|
+    obf = bf.gsub(/#{strip}/, '')
+    install_binfile(bf, obf, target)
+  end
+end
+
+def do_libs(libs, strip = 'lib/')
+  libs.each do |lf|
+    olf = File.join(InstallOptions.site_dir, lf.gsub(/#{strip}/, ''))
+    op = File.dirname(olf)
+    #if File.respond_to?(:makedirs)
+        FileUtils.makedirs(op)
+    #else
+    #    recmkdir(op)
+    #end
+    File.chmod(0755, op)
+    FileUtils.install(lf, olf, :mode => 0755, :verbose => true)
+  end
+end
+
+##
+# Prepare the file installation.
+#
+def prepare_installation
+  InstallOptions.rdoc  = true
+  if RUBY_PLATFORM == "i386-mswin32"
+    InstallOptions.ri  = false
+  else
+    InstallOptions.ri  = true
+  end
+  InstallOptions.tests = true
+
+  ARGV.options do |opts|
+    opts.banner = "Usage: #{File.basename($0)} [options]"
+    opts.separator ""
+    opts.on('--[no-]rdoc', 'Prevents the creation of RDoc output.', 'Default on.') do |onrdoc|
+      InstallOptions.rdoc = onrdoc
+    end
+    opts.on('--[no-]ri', 'Prevents the creation of RI output.', 'Default off on mswin32.') do |onri|
+      InstallOptions.ri = onri
+    end
+    opts.on('--[no-]tests', 'Prevents the execution of unit tests.', 'Default on.') do |ontest|
+      InstallOptions.tests = ontest
+    end
+    opts.on('--quick', 'Performs a quick installation. Only the', 'installation is done.') do |quick|
+      InstallOptions.rdoc   = false
+      InstallOptions.ri     = false
+      InstallOptions.tests  = false
+    end
+    opts.on('--full', 'Performs a full installation. All', 'optional installation steps are run.') do |full|
+      InstallOptions.rdoc   = true
+      InstallOptions.ri     = true
+      InstallOptions.tests  = true
+    end
+    opts.separator("")
+    opts.on_tail('--help', "Shows this help text.") do
+      $stderr.puts opts
+      exit
+    end
+
+    opts.parse!
+  end
+
+  bds = [".", ENV['TMP'], ENV['TEMP'], "/tmp"]
+
+  version = [Config::CONFIG["MAJOR"], Config::CONFIG["MINOR"]].join(".")
+  ld = File.join(Config::CONFIG["libdir"], "ruby", version)
+
+  sd = Config::CONFIG["sitelibdir"]
+  if sd.nil?
+    sd = $:.find { |x| x =~ /site_ruby/ }
+    if sd.nil?
+      sd = File.join(ld, "site_ruby")
+    elsif sd !~ Regexp.quote(version)
+      sd = File.join(sd, version)
+    end
+  end
+
+  if (destdir = ENV['DESTDIR'])
+    bd = "#{destdir}#{Config::CONFIG['bindir']}"
+    sd = "#{destdir}#{sd}"
+    bds << bd
+
+    FileUtils.makedirs(bd)
+    FileUtils.makedirs(sd)
+  else
+    bds << Config::CONFIG['bindir']
+  end
+
+  InstallOptions.bin_dirs = bds.compact
+  InstallOptions.site_dir = sd
+  InstallOptions.bin_dir  = bd
+  InstallOptions.lib_dir  = ld
+
+  unless $loadedrdoc
+      InstallOptions.rdoc  = false
+      InstallOptions.ri  = false
+  end
+end
+
+##
+# Build the rdoc documentation. Also, try to build the RI documentation.
+#
+def build_rdoc(files)
+  r = RDoc::RDoc.new
+  r.document(["--main", "README", "--title", "Facter -- A Fact Collecter",
+              "--line-numbers"] + files)
+
+rescue RDoc::RDocError => e
+  $stderr.puts e.message
+rescue Exception => e
+  $stderr.puts "Couldn't build RDoc documentation\n#{e.message}"
+end
+
+def build_ri(files)
+  ri = RDoc::RDoc.new
+  ri.document(["--ri-site", "--merge"] + files)
+rescue RDoc::RDocError => e
+  $stderr.puts e.message
+rescue Exception => e
+  $stderr.puts e.class
+  $stderr.puts "Couldn't build Ri documentation\n#{e.message}"
+end
+
+def run_tests(test_list)
+	begin
+		require 'test/unit/ui/console/testrunner'
+		$:.unshift "lib"
+		test_list.each do |test|
+		next if File.directory?(test)
+		require test
+		end
+
+		tests = []
+		ObjectSpace.each_object { |o| tests << o if o.kind_of?(Class) } 
+		tests.delete_if { |o| !o.ancestors.include?(Test::Unit::TestCase) }
+		tests.delete_if { |o| o == Test::Unit::TestCase }
+
+		tests.each { |test| Test::Unit::UI::Console::TestRunner.run(test) }
+		$:.shift
+	rescue LoadError
+		puts "Missing testrunner library; skipping tests"
+	end
+end
+
+##
+# Install file(s) from ./bin to Config::CONFIG['bindir']. Patch it on the way
+# to insert a #! line; on a Unix install, the command is named as expected
+# (e.g., bin/rdoc becomes rdoc); the shebang line handles running it. Under
+# windows, we add an '.rb' extension and let file associations do their stuff.
+def install_binfile(from, op_file, target)
+  tmp_dir = nil
+  InstallOptions.bin_dirs.each do |t|
+    if File.directory?(t) and File.writable_real?(t)
+      tmp_dir = t
+      break
+    end
+  end
+  
+  fail "Cannot find a temporary directory" unless tmp_dir
+  tmp_file = File.join(tmp_dir, '_tmp')
+  ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+
+  File.open(from) do |ip|
+    File.open(tmp_file, "w") do |op|
+      ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+      op.puts "#!#{ruby}"
+      op.write ip.read
+    end
+  end
+
+  if Config::CONFIG["target_os"] =~ /win/io
+    installed_wrapper = false
+
+    if File.exists?("#{from}.bat")
+      FileUtils.install("#{from}.bat", File.join(target, "#{op_file}.bat"), :mode => 0755, :verbose => true)
+      installed_wrapper = true
+    end
+
+    if File.exists?("#{from}.cmd")
+      FileUtils.install("#{from}.cmd", File.join(target, "#{op_file}.cmd"), :mode => 0755, :verbose => true)
+      installed_wrapper = true
+    end
+
+    if not installed_wrapper
+      tmp_file2 = File.join(tmp_dir, '_tmp_wrapper')
+      cwn = File.join(Config::CONFIG['bindir'], op_file)
+      cwv = CMD_WRAPPER.gsub('<ruby>', ruby.gsub(%r{/}) { "\\" }).gsub!('<command>', cwn.gsub(%r{/}) { "\\" } )
+
+      File.open(tmp_file2, "wb") { |cw| cw.puts cwv }
+      FileUtils.install(tmp_file2, File.join(target, "#{op_file}.bat"), :mode => 0755, :verbose => true)
+
+      File.unlink(tmp_file2)
+      installed_wrapper = true
+    end
+  end
+  FileUtils.install(tmp_file, File.join(target, op_file), :mode => 0755, :verbose => true)
+  File.unlink(tmp_file)
+end
+
+CMD_WRAPPER = <<-EOS
+@echo off
+if "%OS%"=="Windows_NT" goto WinNT
+<ruby> -x "<command>" %1 %2 %3 %4 %5 %6 %7 %8 %9
+goto done
+:WinNT
+<ruby> -x "<command>" %*
+goto done
+:done
+EOS
+
+prepare_installation
+
+run_tests(tests) if InstallOptions.tests
+build_rdoc(rdoc) if InstallOptions.rdoc
+build_ri(ri) if InstallOptions.ri
+do_bins(bins, Config::CONFIG['bindir'])
+do_libs(libs)

data/lib/facter.rb

@@ -0,0 +1,771 @@
+# $Id: facter.rb 63 2005-11-22 15:25:08Z luke $
+#--
+# Copyright 2004 Luke Kanies <luke@madstop.com>
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+# Ruby licence.
+# 
+#--
+
+#--------------------------------------------------------------------
+class Facter
+    include Comparable
+    include Enumerable
+
+    FACTERVERSION="1.0.0"
+	# = Facter 1.0
+    # Functions as a hash of 'facts' you might care about about your
+    # system, such as mac address, IP address, Video card, etc.
+    # returns them dynamically
+
+	# == Synopsis
+	#
+    # Generally, treat <tt>Facter</tt> as a hash:
+    # == Example
+    # require 'facter'
+    # puts Facter['operatingsystem']
+    #
+
+
+    @@facts = {}
+    GREEN = ""
+    RESET = ""
+    @@debug = 0
+    @@os = nil
+    @@osrel = nil
+
+    attr_accessor :name, :os, :osrel, :hardware, :searching
+
+	#----------------------------------------------------------------
+	# module methods
+	#----------------------------------------------------------------
+
+    def Facter.version
+        return FACTERVERSION
+    end
+
+    def Facter.debug(string)
+        if string.nil?
+            return
+        end
+        if @@debug != 0
+            puts GREEN + string + RESET
+        end
+    end
+
+	#----------------------------------------------------------------
+	def Facter.[](name)
+        if @@facts.include?(name.downcase)
+            return @@facts[name.downcase]
+        else
+            return Facter.add(name)
+        end
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def Facter.add(name)
+        fact = nil
+        dcname = name.downcase
+
+        if @@facts.include?(dcname)
+            fact = @@facts[dcname]
+        else
+            Facter.new(dcname)
+            fact = @@facts[dcname]
+        end
+
+        if block_given?
+            fact.add
+        end
+
+        return fact
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    class << self
+        include Enumerable
+        def each
+            @@facts.each { |name,fact|
+                if fact.suitable?
+                    value = fact.value
+                    unless value.nil?
+                        yield name, fact.value
+                    end
+                end
+            }
+        end
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def Facter.reset
+        @@facts.each { |name,fact|
+            @@facts.delete(name)
+        }
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+	# 
+	def Facter.debugging(bit)
+		if bit
+            case bit
+            when TrueClass: @@debug = 1
+            when FalseClass: @@debug = 0
+            when Fixnum: 
+                if bit > 0
+                    @@debug = 1
+                else
+                    @@debug = 0
+                end
+            when String:
+                if bit.downcase == 'off'
+                    @@debug = 0
+                else
+                    @@debug = 1
+                end
+            else
+                @@debug = 0
+            end
+		else
+			@@debug = 0
+		end
+	end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    #def Facter.init
+    #    @@os = @@facts["operatingsystem"].value
+    #    @@release = @@facts["operatingsystemrelease"].value
+    #end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def Facter.list
+        return @@facts.keys
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def Facter.os
+        return @@os
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def Facter.release
+        return @@release
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def <=>(other)
+        return self.value <=> other
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def initialize(name)
+        @name = name.downcase
+        if @@facts.include?(@name)
+            raise "A fact named %s already exists" % name
+        else
+            @@facts[@name] = self
+        end
+
+        @resolves = []
+        @searching = false
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    # as long as this doesn't work over the 'net, it should probably
+    # be optimized to throw away any resolutions not valid for the machine
+    # it's running on
+    # but that's not currently done...
+    def add
+        resolve = Resolution.new(@name)
+        yield(resolve)
+
+        # skip resolves that will never be suitable for us
+        return unless resolve.suitable?
+
+        # insert resolves in order of number of tags
+        inserted = false
+        @resolves.each_with_index { |r,index|
+            if resolve.length > r.length
+                @resolves.insert(index,resolve)
+                inserted = true
+                break
+            end
+        }
+
+        unless inserted
+            @resolves.push resolve
+        end
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    # iterate across all of the currently configured resolves
+    # sort the resolves in order of most tags first, so we're getting
+    # the most specific answers first, hopefully
+    def each
+#        @resolves.sort { |a,b|
+#            puts "for tag %s, alength is %s and blength is %s" %
+#                [@name, a.length, b.length]
+#            b.length <=> a.length
+#        }.each { |resolve|
+#            yield resolve
+#        }
+        @resolves.each { |r| yield r }
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    # return a count of resolution mechanisms available
+    def count
+        return @resolves.length
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    # is this fact suitable for finding answers on this host?
+    # again, this should really be optimizing by throwing away everything
+    # not suitable, but...
+    def suitable?
+        return false if @resolves.length == 0
+
+        unless defined? @suitable
+            @suitable = false
+            self.each { |resolve|
+                if resolve.suitable?
+                    @suitable = true
+                    break
+                end
+            }
+        end
+
+        return @suitable
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    def value
+        # make sure we don't get stuck in recursive dependency loops
+        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
+        @value = nil
+        foundsuits = false
+
+        if @resolves.length == 0
+            Facter.debug "No resolves for %s" % @name
+            return nil
+        end
+
+        @searching = true
+        @resolves.each { |resolve|
+            #Facter.debug "Searching resolves for %s" % @name
+            if resolve.suitable?
+                @value = resolve.value
+                foundsuits = true
+            else
+                Facter.debug "Unsuitable resolve %s for %s" % [resolve,@name]
+            end
+            unless @value.nil? or @value == ""
+                break
+            end
+        }
+        @searching = false
+
+        unless foundsuits
+            Facter.debug "Found no suitable resolves of %s for %s" %
+                [@resolves.length,@name]
+        end
+
+        if @value.nil?
+            # nothing
+            Facter.debug("value for %s is still nil" % @name)
+            return nil
+        else
+            return @value
+        end
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    class Resolution
+        attr_accessor :interpreter, :code, :name
+
+        def Resolution.exec(code, interpreter = "/bin/sh")
+            if interpreter == "/bin/sh"
+                binary = code.split(/\s+/).shift
+
+                path = nil
+                if binary !~ /^\//
+                    path = %x{which #{binary} 2>/dev/null}.chomp
+                    if path == ""
+                        # we don't have the binary necessary
+                        return nil
+                    end
+                else
+                    path = binary
+                end
+
+                unless FileTest.exists?(path)
+                    # our binary does not exist
+                    return nil
+                end
+                out = nil
+                begin
+                    out = %x{#{code}}.chomp
+                rescue => detail
+                    $stderr.puts detail
+                end
+                if out == ""
+                    return nil
+                else
+                    return out
+                end
+            else
+                raise "non-sh interpreters are not currently supported"
+            end
+        end
+
+        def initialize(name)
+            @name = name
+            @tags = []
+        end
+
+        def length
+            @tags.length
+        end
+
+        def suitable?
+            unless defined? @suitable
+                @suitable = true
+                if @tags.length == 0
+                    #Facter.debug "'%s' has no tags" % @name
+                    return true
+                end
+                @tags.each { |tag|
+                    unless tag.true?
+                        #Facter.debug "'%s' is false" % tag
+                        @suitable = false
+                    end
+                }
+            end
+
+            return @suitable
+        end
+
+        def tag(fact,op,value)
+            @tags.push Tag.new(fact,op,value)
+        end
+
+        def to_s
+            return self.value()
+        end
+
+        # how we get a value for our resolution mechanism
+        def value
+            #puts "called %s value" % @name
+            value = nil
+            if @code.is_a?(Proc)
+                value = @code.call()
+            else
+                unless defined? @interpreter
+                    @interpreter = "/bin/sh"
+                end
+                if @code.nil?
+                    $stderr.puts "Code for %s is nil" % @name
+                else
+                    value = Resolution.exec(@code,@interpreter)
+                end
+            end
+
+            if value == ""
+                value = nil
+            end
+
+            return value
+        end
+    end
+	#----------------------------------------------------------------
+
+	#----------------------------------------------------------------
+    class Tag
+        attr_accessor :fact, :op, :value
+
+        def initialize(fact,op,value)
+            @fact = fact
+            if op == "="
+                op = "=="
+            end
+            @op = op
+            @value = value
+        end
+
+        def to_s
+            return "'%s' %s '%s'" % [@fact,@op,@value]
+        end
+
+        def true?
+            value = Facter[@fact].value
+
+            if value.nil?
+                return false
+            end
+
+            str = "'%s' %s '%s'" % [value,@op,@value]
+            begin
+                if eval(str)
+                    return true
+                else
+                    return false
+                end
+            rescue => detail
+                $stderr.puts "Failed to test '%s': %s" % [str,detail]
+                return false
+            end
+        end
+    end
+	#----------------------------------------------------------------
+
+    # Load all of the default facts
+    def Facter.load
+        Facter["OperatingSystem"].add { |obj|
+            obj.code = 'uname -s'
+        }
+
+        Facter["OperatingSystemRelease"].add { |obj|
+            obj.code = 'uname -r'
+        }
+
+        Facter["HardwareModel"].add { |obj|
+            obj.code = 'uname -m'
+            #obj.os = "SunOS"
+            #obj.tag("operatingsystem","=","SunOS")
+        }
+
+        Facter["CfKey"].add { |obj|
+            obj.code = proc {
+                value = nil
+                ["/usr/local/etc/cfkey.pub",
+                    "/etc/cfkey.pub",
+                    "/var/cfng/keys/localhost.pub",
+                    "/var/cfengine/ppkeys/localhost.pub"
+                ].each { |file|
+                    if FileTest.file?(file)
+                        File.open(file) { |openfile|
+                            value = openfile.readlines.reject { |line|
+                                line =~ /PUBLIC KEY/
+                            }.collect { |line|
+                                line.chomp
+                            }.join("")
+                        }
+                    end
+                    if value
+                        break
+                    end
+                }
+
+                value
+            }
+        }
+
+        Facter["Domain"].add { |obj|
+            obj.code = proc {
+                if defined? $domain and ! $domain.nil?
+                    $domain
+                end
+            }
+        }
+        Facter["Domain"].add { |obj|
+            obj.code = proc {
+                domain = Resolution.exec('domainname')
+                # make sure it's a real domain
+                if domain =~ /.+\..+/
+                    domain
+                else
+                    nil
+                end
+            }
+        }
+        Facter["Domain"].add { |obj|
+            obj.code = proc {
+                value = nil
+                unless FileTest.exists?("/etc/resolv.conf")
+                    return nil
+                end
+                File.open("/etc/resolv.conf") { |file|
+                    # is the domain set?
+                    file.each { |line|
+                        if line =~ /domain\s+(\S+)/
+                            value = $1
+                            break
+                        end
+                    }
+                }
+                ! value and File.open("/etc/resolv.conf") { |file|
+                    # is the search path set?
+                    file.each { |line|
+                        if line =~ /search\s+(\S+)/
+                            value = $1
+                            break
+                        end
+                    }
+                }
+                value
+            }
+        }
+        Facter["Hostname"].add { |obj|
+            obj.code = proc {
+                hostname = nil
+                name = Resolution.exec('hostname')
+                if name =~ /^([\w-]+)\.(.+)$/
+                    hostname = $1
+                    # the Domain class uses this
+                    $domain = $2
+                else
+                    hostname = name
+                end
+                hostname
+            }
+        }
+
+        Facter["IPHostNumber"].add { |obj|
+            obj.code = proc {
+                require 'resolv'
+
+                begin
+                    hostname = Facter["hostname"].value
+                    ip = Resolv.getaddress(hostname)
+                    unless ip == "127.0.0.1"
+                        ip
+                    end
+                rescue Resolv::ResolvError
+                    nil
+                rescue NoMethodError # i think this is a bug in resolv.rb?
+                    nil
+                end
+            }
+        }
+        Facter["IPHostNumber"].add { |obj|
+            obj.code = proc {
+                hostname = Facter["hostname"].value
+                # crap, we need Hostname to exist for this to
+                # work
+                list = Resolution.exec("host #{hostname}").chomp.split(/\s/)
+                if defined? list[-1] and list[-1] =~ /[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/
+                    list[-1]
+                end
+            }
+        }
+
+        ["/etc/ssh","/usr/local/etc/ssh","/etc","/usr/local/etc"].each { |dir|
+            {"SSHDSAKey" => "ssh_host_dsa_key.pub",
+                    "SSHRSAKey" => "ssh_host_rsa_key.pub"}.each { |name,file|
+                Facter[name].add { |obj|
+                    obj.code = proc {
+                        value = nil
+                        filepath = File.join(dir,file)
+                        if FileTest.file?(filepath)
+                            begin
+                                value = File.open(filepath).read.chomp
+                            rescue
+                                return nil
+                            end
+                        end
+                        return value
+                    } # end of proc
+                } # end of add
+            } # end of hash each
+        } # end of dir each
+
+        Facter["UniqueId"].add { |obj|
+            obj.code = 'hostid'
+            obj.interpreter = '/bin/sh'
+            obj.tag("operatingsystem","=","SunOS")
+            #obj.os = "SunOS"
+        }
+        Facter["HardwareISA"].add { |obj|
+            obj.code = 'uname -p'
+            obj.interpreter = '/bin/sh'
+            #obj.os = "SunOS"
+            obj.tag("operatingsystem","=","SunOS")
+        }
+        Facter["MacAddress"].add { |obj|
+            #obj.os = "SunOS"
+            obj.tag("operatingsystem","=","SunOS")
+            obj.code = proc {
+                ether = nil
+                output = %x{/sbin/ifconfig -a}
+
+                output =~ /ether (\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2})/
+                ether = $1
+
+                ether
+            }
+        }
+        Facter["MacAddress"].add { |obj|
+            #obj.os = "Darwin"
+            obj.tag("operatingsystem","=","Darwin")
+            obj.code = proc {
+                ether = nil
+                output = %x{/sbin/ifconfig}
+
+                output.split(/^\S/).each { |str|
+                    if str =~ /10baseT/ # we're wired
+                        str =~ /ether (\w\w:\w\w:\w\w:\w\w:\w\w:\w\w)/
+                        ether = $1
+                    end
+                }
+
+                ether
+            }
+        }
+        Facter["IPHostnumber"].add { |obj|
+            #obj.os = "Darwin"
+            obj.tag("operatingsystem","=","Darwin")
+            obj.code = proc {
+                ip = nil
+                output = %x{/sbin/ifconfig}
+
+                output.split(/^\S/).each { |str|
+                    if str =~ /inet ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
+                        tmp = $1
+                        unless tmp =~ /127\./
+                            ip = tmp
+                            break
+                        end
+                    end
+                }
+
+                ip
+            }
+        }
+        Facter["Hostname"].add { |obj|
+            #obj.os = "Darwin"
+            #obj.release = "R7"
+            obj.tag("operatingsystem","=","Darwin")
+            obj.tag("operatingsystemrelease","=","R7")
+            obj.code = proc {
+                hostname = nil
+                File.open(
+                    "/Library/Preferences/SystemConfiguration/preferences.plist"
+                ) { |file|
+                    found = 0
+                    file.each { |line|
+                        if line =~ /ComputerName/i
+                            found = 1
+                            next
+                        end
+                        if found == 1
+                            if line =~ /<string>([\w|-]+)<\/string>/
+                                hostname = $1
+                                break
+                            end
+                        end
+                    }
+                }
+
+                if hostname != nil
+                    hostname
+                end
+            }
+        }
+        Facter["IPHostnumber"].add { |obj|
+            #obj.os = "Darwin"
+            #obj.release = "R6"
+            obj.tag("operatingsystem","=","Darwin")
+            obj.tag("operatingsystemrelease","=","R6")
+            obj.code = proc {
+                hostname = nil
+                File.open(
+                    "/var/db/SystemConfiguration/preferences.xml"
+                ) { |file|
+                    found = 0
+                    file.each { |line|
+                        if line =~ /ComputerName/i
+                            found = 1
+                            next
+                        end
+                        if found == 1
+                            if line =~ /<string>([\w|-]+)<\/string>/
+                                hostname = $1
+                                break
+                            end
+                        end
+                    }
+                }
+
+                if hostname != nil
+                    hostname
+                end
+            }
+        }
+        Facter["IPHostnumber"].add { |obj|
+            #obj.os = "Darwin"
+            #obj.release = "R6"
+            obj.tag("operatingsystem","=","Darwin")
+            obj.tag("operatingsystemrelease","=","R6")
+            obj.code = proc {
+                ether = nil
+                output = %x{/sbin/ifconfig}
+
+                output =~ /HWaddr (\w\w:\w\w:\w\w:\w\w:\w\w:\w\w)/
+                ether = $1
+
+                ether
+            }
+        }
+        Facter["Distro"].add { |obj|
+            #obj.os = "Linux"
+            obj.tag("operatingsystem","=","Linux")
+            obj.code = proc {
+                if FileTest.exists?("/etc/debian_version")
+                    return "Debian"
+                elsif FileTest.exists?("/etc/gentoo-release")
+                    return "Gentoo"
+                elsif FileTest.exists?("/etc/fedora-release")
+                    return "Fedora"
+                elsif FileTest.exists?("/etc/redhat-release")
+                    return "RedHat"
+                end
+            }
+        }
+        Facter["ps"].add { |obj|
+            obj.code = "echo 'ps -ef'"
+        }
+        Facter["ps"].add { |obj|
+            obj.tag("operatingsystem","=","Darwin")
+            obj.code = "echo 'ps -auxwww'"
+        }
+
+        Facter["id"].add { |obj|
+            obj.tag("operatingsystem","=","Linux")
+            obj.code = "whoami"
+        }
+    end
+
+    Facter.load
+end
+
+# try to load a local fact library, if there happens to be one
+begin
+    require 'facter/local'
+rescue LoadError
+    # no worries
+end