facter 1.5.8 → 1.5.9

data/lib/facter/application.rb

@@ -0,0 +1,123 @@
+module Facter
+  module Application
+    def self.run(argv)
+      require 'optparse'
+      require 'facter'
+
+      options = parse(argv)
+
+      # Accept fact names to return from the command line
+      names = argv
+
+      # Create the facts hash that is printed to standard out.
+      # Pre-load all of the facts, since we can have multiple facts
+      # per file, and since we can't know ahead of time which file a
+      # fact will be in, we'll need to load every file.
+      facts = Facter.to_hash
+      unless names.empty?
+        facts = {}
+        names.each do |name|
+          begin
+            facts[name] = Facter.value(name)
+          rescue => error
+            $stderr.puts "Could not retrieve #{name}: #{error}"
+            exit 10
+          end
+        end
+      end
+
+      # Print the facts as YAML and exit
+      if options[:yaml]
+        require 'yaml'
+        puts YAML.dump(facts)
+        exit(0)
+      end
+
+      # Print the facts as JSON and exit
+      if options[:json]
+        begin
+          require 'json'
+          puts JSON.dump(facts)
+          exit(0)
+        rescue LoadError
+          $stderr.puts "You do not have JSON support in your version of Ruby. JSON output disabled"
+          exit(1)
+        end
+      end
+
+      # Print the value of a single fact, otherwise print a list sorted by fact
+      # name and separated by "=>"
+      if facts.length == 1
+        if value = facts.values.first
+          puts value
+        end
+      else
+        facts.sort_by{ |fact| fact.first }.each do |name,value|
+          puts "#{name} => #{value}"
+        end
+      end
+
+    rescue => e
+      if options && options[:trace]
+        raise e
+      else
+        $stderr.puts "Error: #{e}"
+        exit(12)
+      end
+    end
+
+    private
+
+    def self.parse(argv)
+      options = {}
+      OptionParser.new do |opts|
+        opts.on("-y", "--yaml")   { |v| options[:yaml]   = v }
+        opts.on("-j", "--json")   { |v| options[:json]   = v }
+        opts.on(      "--trace")  { |v| options[:trace]  = v }
+        opts.on("-d", "--debug")  { |v| Facter.debugging(1) }
+        opts.on("-t", "--timing") { |v| Facter.timing(1) }
+        opts.on("-p", "--puppet") { |v| load_puppet }
+
+        opts.on_tail("-v", "--version") do
+          puts Facter.version
+          exit(0)
+        end
+
+        opts.on_tail("-h", "--help") do
+          begin
+            require 'rdoc/ri/ri_paths'
+            require 'rdoc/usage'
+            RDoc.usage # print usage and exit
+          rescue LoadError
+            $stderr.puts "No help available unless your RDoc has RDoc.usage"
+            exit(1)
+          rescue => e
+            $stderr.puts "fatal: #{e}"
+            exit(1)
+          end
+        end
+      end.parse!
+
+      options
+    rescue OptionParser::InvalidOption => e
+      $stderr.puts e.message
+      exit(12)
+    end
+
+    def self.load_puppet
+      require 'puppet'
+      Puppet.parse_config
+
+      # If you've set 'vardir' but not 'libdir' in your
+      # puppet.conf, then the hook to add libdir to $:
+      # won't get triggered.  This makes sure that it's setup
+      # correctly.
+      unless $LOAD_PATH.include?(Puppet[:libdir])
+        $LOAD_PATH << Puppet[:libdir]
+      end
+    rescue LoadError => detail
+      $stderr.puts "Could not load Puppet: #{detail}"
+    end
+
+  end
+end

data/lib/facter/arp.rb

@@ -0,0 +1,28 @@
+require 'facter/util/ip'
+
+Facter.add(:arp) do
+  confine :kernel => :linux
+  setcode do
+    output = Facter::Util::Resolution.exec('arp -a')
+    if not output.nil?
+      arp = ""
+      output.each_line do |s|
+        if s =~ /^\S+\s\S+\s\S+\s(\S+)\s\S+\s\S+\s\S+$/
+          arp = $1.downcase
+          break # stops on the first match
+        end
+      end
+    end
+    "fe:ff:ff:ff:ff:ff" == arp ? arp : nil
+  end
+end
+
+Facter::Util::IP.get_interfaces.each do |interface|
+  Facter.add("arp_" + Facter::Util::IP.alphafy(interface)) do
+    confine :kernel => :linux
+    setcode do
+      arp = Facter::Util::IP.get_arp_value(interface)
+      "fe:ff:ff:ff:ff:ff" == arp ? arp : nil
+    end
+  end
+end

data/lib/facter/ec2.rb

@@ -1,18 +1,21 @@
-# Changelog:
-# Original facts - Tim Dysinger
-# Updated and added can_connect? function - KurtBe
+# Original fact Tim Dysinger
+# Additional work from KurtBe
+# Additional work for Paul Nasrat
+# Additional work modelled on Ohai EC2 fact
 
 require 'open-uri'
 require 'timeout'
 
-def can_connect?(ip,port,wait_sec=2)
- Timeout::timeout(wait_sec) {open(ip, port)}
- return true
-rescue
-  return false
+def can_connect?(wait_sec=2)
+  url = "http://169.254.169.254:80/"
+  Timeout::timeout(wait_sec) {open(url)}
+  return true
+  rescue Timeout::Error
+    return false
+  rescue
+    return false
 end
 
-
 def metadata(id = "")
   open("http://169.254.169.254/2008-02-01/meta-data/#{id||=''}").read.
     split("\n").each do |o|
@@ -29,7 +32,25 @@ def metadata(id = "")
   end
 end
 
-if can_connect?("169.254.169.254","80")
-  metadata
+def userdata()
+  begin
+     value = OpenURI.open_uri("http://169.254.169.254/2008-02-01/user-data/").read.split
+     Facter.add(:ec2_userdata) { setcode { value } }
+  rescue OpenURI::HTTPError
+  end
+end
+
+def has_euca_mac?
+  !!(Facter.value(:macaddress) =~ %r{^[dD]0:0[dD]:})
 end
 
+def has_ec2_arp?
+  !!(Facter.value(:arp) == "fe:ff:ff:ff:ff:ff")
+end
+
+if (has_euca_mac? || has_ec2_arp?) && can_connect?
+  metadata
+  userdata
+else
+  Facter.debug "Not an EC2 host"
+end

data/lib/facter/hardwareisa.rb

@@ -1,4 +1,4 @@
 Facter.add(:hardwareisa) do
     setcode 'uname -p', '/bin/sh'
-    confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS SuSE SLES Debian Ubuntu Gentoo FreeBSD OpenBSD NetBSD OEL OVS}
+    confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS SuSE SLES Debian Ubuntu Gentoo FreeBSD OpenBSD NetBSD OEL OVS GNU/kFreeBSD}
 end

data/lib/facter/id.rb

@@ -1,15 +1,8 @@
 Facter.add(:id) do
-    confine :operatingsystem => %w{Linux Fedora RedHat CentOS SuSE SLES Debian Ubuntu Gentoo AIX OEL OVS}
     setcode "whoami"
 end
 
 Facter.add(:id) do
-    confine :operatingsystem => %w{Solaris}
-    setcode do
-        if %x{id} =~ /^uid=\d+\((\S+)\)/
-            $1
-        else
-            nil
-        end
-    end
+    confine :kernel => :SunOS
+    setcode "/usr/xpg4/bin/id -un"
 end

data/lib/facter/interfaces.rb

@@ -22,7 +22,7 @@ Facter::Util::IP.get_interfaces.each do |interface|
     # Make a fact for each detail of each interface.  Yay.
     #   There's no point in confining these facts, since we wouldn't be able to create
     # them if we weren't running on a supported platform.
-    %w{ipaddress macaddress netmask}.each do |label|
+    %w{ipaddress ipaddress6 macaddress netmask}.each do |label|
         Facter.add(label + "_" + Facter::Util::IP.alphafy(interface)) do
             setcode do
                 Facter::Util::IP.get_interface_value(interface, label)

data/lib/facter/ipaddress.rb

@@ -19,7 +19,7 @@ Facter.add(:ipaddress) do
 end
 
 Facter.add(:ipaddress) do
-    confine :kernel => %w{FreeBSD OpenBSD}
+    confine :kernel => %w{FreeBSD OpenBSD Darwin}
     setcode do
         ip = nil
         output = %x{/sbin/ifconfig}
@@ -47,38 +47,7 @@ Facter.add(:ipaddress) do
         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
-    end
-end
-
-Facter.add(:ipaddress) do
-    confine :kernel => %w{darwin}
-    setcode do
-        ip = nil
-        iface = ""
-        output = %x{/usr/sbin/netstat -rn}
-        if output =~ /^default\s*\S*\s*\S*\s*\S*\s*\S*\s*(\S*).*/
-          iface = $1
-        else
-          warn "Could not find a default route. Using first non-loopback interface"
-        end
-        if(iface != "")
-          output = %x{/sbin/ifconfig #{iface}}
-        else
-          output = %x{/sbin/ifconfig}
-        end
-
-        output.split(/^\S/).each { |str|
-            if str =~ /inet ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/
-                tmp = $1
-                unless tmp =~ /^127\./
+                unless tmp =~ /^127\./ or tmp == "0.0.0.0"
                     ip = tmp
                     break
                 end

data/lib/facter/ipaddress6.rb

@@ -0,0 +1,68 @@
+# Cody Herriges <c.a.herriges@gmail.com>
+#
+# Used the ipaddress fact that is already part of
+# Facter as a template.
+
+# OS dependant code that parses the output of various networking
+# tools and currently not very intelligent. Returns the first
+# non-loopback and non-linklocal address found in the ouput unless
+# a default route can be mapped to a routeable interface. Guessing
+# an interface is currently only possible with BSD type systems
+# to many assumptions have to be made on other platforms to make
+# this work with the current code. Most code ported or modeled
+# after the ipaddress fact for the sake of similar functionality
+# and familiar mechanics.
+Facter.add(:ipaddress6) do
+  confine :kernel => :linux
+  setcode do
+    ip = nil
+    output = Facter::Util::Resolution.exec('/sbin/ifconfig')
+
+    output.scan(/inet6 addr: ((?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/).each { |str|
+      str = str.to_s
+      unless str =~ /fe80.*/ or str == "::1"
+        ip = str
+      end
+    }
+
+    ip
+
+  end
+end
+
+Facter.add(:ipaddress6) do
+  confine :kernel => %w{SunOS}
+  setcode do
+    output = Facter::Util::Resolution.exec('/usr/sbin/ifconfig -a')
+    ip = nil
+
+    output.scan(/inet6 ((?>[0-9,a-f,A-F]*\:{0,2})+[0-9,a-f,A-F]{0,4})/).each { |str|
+      str = str.to_s
+      unless str =~ /fe80.*/ or str == "::1"
+        ip = str
+      end
+    }
+
+    ip
+
+  end
+end
+
+Facter.add(:ipaddress6) do
+  confine :kernel => %w{Darwin FreeBSD OpenBSD}
+  setcode do
+    output = Facter::Util::Resolution.exec('/sbin/ifconfig -a')
+    ip = nil
+
+    output.scan(/inet6 ((?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/).each do |str|
+      str = str.to_s
+      unless str =~ /fe80.*/ or str == "::1"
+        ip = str
+        break
+      end
+    end
+
+    ip
+  end
+end
+

data/lib/facter/lsb.rb

@@ -20,15 +20,15 @@
    "LSBDistCodeName"    => %r{^Codename:\t(.*)$}
 }.each do |fact, pattern|
     Facter.add(fact) do
-        confine :kernel => :linux
+        confine :kernel => [ :linux, :"gnu/kfreebsd" ]
         setcode do
-            unless defined?(@@lsbdata) and defined?(@@lsbtime) and (Time.now.to_i - @@lsbtime.to_i < 5)
+            unless defined?(lsbdata) and defined?(lsbtime) and (Time.now.to_i - lsbtime.to_i < 5)
                 type = nil
-                @@lsbtime = Time.now
-                @@lsbdata = Facter::Util::Resolution.exec('lsb_release -a 2>/dev/null')
+                lsbtime = Time.now
+                lsbdata = Facter::Util::Resolution.exec('lsb_release -a 2>/dev/null')
             end
 
-            if pattern.match(@@lsbdata)
+            if pattern.match(lsbdata)
                 $1
             else
                 nil

data/lib/facter/lsbmajdistrelease.rb

@@ -3,7 +3,7 @@
 require 'facter'
 
 Facter.add("lsbmajdistrelease") do
-    confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS SuSE SLES Debian Ubuntu Gentoo OEL OVS}
+    confine :operatingsystem => %w{Linux Fedora RedHat CentOS SuSE SLES Debian Ubuntu Gentoo OEL OVS GNU/kFreeBSD}
     setcode do
         if /(\d*)\./i =~ Facter.value(:lsbdistrelease)
             result=$1

data/lib/facter/macaddress.rb

@@ -1,5 +1,7 @@
+require 'facter/util/macaddress'
+
 Facter.add(:macaddress) do
-    confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS SuSE SLES Debian Gentoo Ubuntu OEL OVS}
+    confine :operatingsystem => %w{Solaris Linux Fedora RedHat CentOS SuSE SLES Debian Gentoo Ubuntu OEL OVS GNU/kFreeBSD}
     setcode do
         ether = []
         output = %x{/sbin/ifconfig -a}
@@ -26,19 +28,7 @@ end
 
 Facter.add(:macaddress) do
     confine :kernel => :darwin
-    setcode do
-        ether = nil
-        output = %x{/sbin/ifconfig}
-
-        output.split(/^\S/).each do |str|
-            if str =~ /10baseT/ # we're wired
-                str =~ /ether (\w\w:\w\w:\w\w:\w\w:\w\w:\w\w)/
-                ether = $1
-            end
-        end
-
-        ether
-    end
+    setcode { Facter::Util::Macaddress::Darwin.macaddress }
 end
 
 Facter.add(:macaddress) do

data/lib/facter/manufacturer.rb

@@ -13,6 +13,15 @@ if Facter.value(:kernel) == "OpenBSD"
     }
 
     Facter::Manufacturer.sysctl_find_system_info(mfg_keys)
+elsif Facter.value(:kernel) == "SunOS" and Facter.value(:hardwareisa) == "sparc"
+    Facter::Manufacturer.prtdiag_sparc_find_system_info()
+elsif Facter.value(:kernel) == "windows"
+    win32_keys = {
+        'manufacturer' => ['Manufacturer', 'Bios'],
+        'serialNumber' => ['Serialnumber', 'Bios'],
+        'productname'  => ['Name', 'ComputerSystemProduct']
+    }
+    Facter::Manufacturer.win32_find_system_info(win32_keys)
 else
     query = {
         '[Ss]ystem [Ii]nformation' => [

data/lib/facter/memory.rb

@@ -13,13 +13,43 @@ require 'facter/util/memory'
     :SwapFree   => "SwapFree"
 }.each do |fact, name|
     Facter.add(fact) do
-        confine :kernel => :linux
+        confine :kernel => [ :linux, :"gnu/kfreebsd" ]
         setcode do
             Facter::Memory.meminfo_number(name)
         end
     end
 end
 
+Facter.add("SwapSize") do
+    confine :kernel => :Darwin
+    setcode do
+	swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
+	swaptotal = 0
+	if swap =~ /total = (\S+)/ then swaptotal = $1; end
+	swaptotal
+    end
+end
+
+Facter.add("SwapFree") do
+    confine :kernel => :Darwin
+    setcode do
+	swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
+	swapfree = 0
+	if swap =~ /free = (\S+)/ then swapfree = $1; end
+	swapfree
+    end
+end
+
+Facter.add("SwapEncrypted") do
+    confine :kernel => :Darwin
+    setcode do
+	swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
+	encrypted = false
+	if swap =~ /\(encrypted\)/ then encrypted = true; end
+	encrypted
+    end
+end
+
 if Facter.value(:kernel) == "AIX" and Facter.value(:id) == "root"
     swap = Facter::Util::Resolution.exec('swap -l')
     swapfree, swaptotal = 0, 0
@@ -69,19 +99,93 @@ if Facter.value(:kernel) == "OpenBSD"
         end
     end
 
-    Facter.add("MemoryFree") do
+    Facter::Memory.vmstat_find_free_memory()
+
+    Facter.add("MemoryTotal") do
         confine :kernel => :openbsd
-        memfree = Facter::Util::Resolution.exec("vmstat | tail -n 1 | awk '{ print $5 }'")
+        memtotal = Facter::Util::Resolution.exec("sysctl hw.physmem | cut -d'=' -f2")
+        setcode do
+            Facter::Memory.scale_number(memtotal.to_f,"")
+        end
+    end
+end
+
+if Facter.value(:kernel) == "Darwin"
+    swap = Facter::Util::Resolution.exec('sysctl vm.swapusage')
+    swapfree, swaptotal = 0, 0
+    unless swap.empty?
+        # Parse the line:
+        # vm.swapusage: total = 128.00M  used = 0.37M  free = 127.63M  (encrypted)
+        if swap =~ /total\s=\s(\S+)\s+used\s=\s(\S+)\s+free\s=\s(\S+)\s/
+            swaptotal += $1.to_i
+            swapfree  += $3.to_i
+        end
+    end
+
+    Facter.add("SwapSize") do
+        confine :kernel => :Darwin
         setcode do
-            Facter::Memory.scale_number(memfree.to_f,"kB")
+            Facter::Memory.scale_number(swaptotal.to_f,"MB")
         end
     end
 
+    Facter.add("SwapFree") do
+        confine :kernel => :Darwin
+        setcode do
+            Facter::Memory.scale_number(swapfree.to_f,"MB")
+        end
+    end
+
+    Facter::Memory.vmstat_darwin_find_free_memory()
+
     Facter.add("MemoryTotal") do
-        confine :kernel => :openbsd
-        memtotal = Facter::Util::Resolution.exec("sysctl hw.physmem | cut -d'=' -f2")
+        confine :kernel => :Darwin
+        memtotal = Facter::Util::Resolution.exec("sysctl hw.memsize | cut -d':' -f2")
         setcode do
             Facter::Memory.scale_number(memtotal.to_f,"")
         end
     end
 end
+
+if Facter.value(:kernel) == "SunOS"
+    swap = Facter::Util::Resolution.exec('/usr/sbin/swap -l')
+    swapfree, swaptotal = 0, 0
+    swap.each do |dev|
+        if dev =~ /^\/\S+\s.*\s+(\d+)\s+(\d+)$/
+            swaptotal += $1.to_i / 2
+            swapfree  += $2.to_i / 2
+        end 
+    end 
+ 
+    Facter.add("SwapSize") do
+        confine :kernel => :sunos
+        setcode do
+            Facter::Memory.scale_number(swaptotal.to_f,"kB")
+        end
+    end
+
+    Facter.add("SwapFree") do
+        confine :kernel => :sunos
+        setcode do
+            Facter::Memory.scale_number(swapfree.to_f,"kB")
+        end
+    end
+
+    # Total memory size available from prtconf
+    pconf = Facter::Util::Resolution.exec('/usr/sbin/prtconf')
+    phymem = ""
+    pconf.each do |line|
+        if line =~ /^Memory size:\s+(\d+) Megabytes/
+            phymem = $1
+        end
+    end
+
+    Facter.add("MemorySize") do
+        confine :kernel => :sunos
+        setcode do
+            Facter::Memory.scale_number(phymem.to_f,"MB")
+        end
+    end
+
+    Facter::Memory.vmstat_find_free_memory()
+end