bolt 0.0.1 → 0.5.0

data/vendored/facter/lib/facter/util/loader.rb

@@ -0,0 +1,155 @@
+require 'facter'
+require 'pathname'
+require 'facter/util/directory_loader'
+
+# Load facts on demand.
+class Facter::Util::Loader
+
+  def initialize(environment_vars = ENV)
+    @loaded = []
+    @environment_vars = environment_vars
+  end
+
+  # Load all resolutions for a single fact.
+  #
+  # @api public
+  # @param name [Symbol]
+  def load(fact)
+    # Now load from the search path
+    shortname = fact.to_s.downcase
+    load_env(shortname)
+
+    filename = shortname + ".rb"
+
+    paths = search_path
+    unless paths.nil?
+      paths.each do |dir|
+        # Load individual files
+        file = File.join(dir, filename)
+
+        load_file(file) if File.file?(file)
+      end
+    end
+  end
+
+  # Load all facts from all directories.
+  #
+  # @api public
+  def load_all
+    return if defined?(@loaded_all)
+
+    load_env
+
+    paths = search_path
+    unless paths.nil?
+      paths.each do |dir|
+        # dir is already an absolute path
+        Dir.glob(File.join(dir, '*.rb')).each do |path|
+          # exclude dirs that end with .rb
+          load_file(path) if File.file?(path)
+        end
+      end
+    end
+
+    @loaded_all = true
+  end
+
+  # List directories to search for fact files.
+  #
+  # Search paths are gathered from the following sources:
+  #
+  # 1. $LOAD_PATH entries are expanded to absolute paths
+  # 2. ENV['FACTERLIB'] is split and used verbatim
+  # 3. Entries from Facter.search_path are used verbatim
+  #
+  # A warning will be generated for paths in Facter.search_path that are not
+  # absolute directories.
+  #
+  # @api public
+  # @return [Array<String>]
+  def search_path
+    search_paths = []
+    search_paths += $LOAD_PATH.map { |path| File.expand_path('facter', path) }
+
+    if @environment_vars.include?("FACTERLIB")
+      search_paths += @environment_vars["FACTERLIB"].split(File::PATH_SEPARATOR)
+    end
+
+    search_paths.delete_if { |path| ! valid_search_path?(path) }
+
+    Facter.search_path.each do |path|
+      if valid_search_path?(path)
+        search_paths << path
+      else
+        Facter.warn "Excluding #{path} from search path. Fact file paths must be an absolute directory"
+      end
+    end
+
+    search_paths.delete_if { |path| ! File.directory?(path) }
+
+    search_paths.uniq
+  end
+
+  private
+
+  # Validate that the given path is valid, ie it is an absolute path.
+  #
+  # @api private
+  # @param path [String]
+  # @return [Boolean]
+  def valid_search_path?(path)
+    Pathname.new(path).absolute?
+  end
+
+  # Load a file and record is paths to prevent duplicate loads.
+  #
+  # @api private
+  # @params file [String] The *absolute path* to the file to load
+  def load_file(file)
+    return if @loaded.include? file
+
+    # We have to specify Kernel.load, because we have a load method.
+    begin
+      # Store the file path so we don't try to reload it
+      @loaded << file
+      kernel_load(file)
+    rescue ScriptError => detail
+      # Don't store the path if the file can't be loaded
+      # in case it's loadable later on.
+      @loaded.delete(file)
+      Facter.log_exception(detail, "Error loading fact #{file}: #{detail.message}")
+    end
+  end
+
+  # Load and execute the Ruby program specified in the file. This exists
+  # for testing purposes.
+  #
+  # @api private
+  # @return [Boolean]
+  def kernel_load(file)
+    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
+    @environment_vars.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
+        has_weight 1_000_000
+        setcode { value }
+      end
+
+      # Short-cut, if we are only looking for one value.
+      break if fact
+    end
+  end
+end

data/vendored/facter/lib/facter/util/macaddress.rb

@@ -0,0 +1,43 @@
+# A module to gather macaddress facts
+#
+module Facter::Util::Macaddress
+
+  def self.standardize(macaddress)
+    return nil unless macaddress
+    macaddress.split(":").map{|x| "0#{x}"[-2..-1]}.join(":")
+  end
+
+  module Darwin
+    def self.macaddress
+      iface = default_interface
+      Facter.warn "Could not find a default route. Using first non-loopback interface" if iface.empty?
+
+      macaddress = `#{ifconfig_command} #{iface} | /usr/bin/awk '/ether/{print $2;exit}'`.chomp
+      macaddress.empty? ? nil : macaddress
+    end
+
+    def self.default_interface
+      `#{netstat_command} | /usr/bin/awk  '/^default/{print $6;exit}'`.chomp
+    end
+
+    private
+
+    def self.netstat_command
+      '/usr/sbin/netstat -rn'
+    end
+
+    def self.ifconfig_command
+      '/sbin/ifconfig'
+    end
+  end
+
+  module Windows
+    def macaddress
+      require 'facter/util/ip/windows'
+
+      adapter = Facter::Util::IP::Windows.get_preferred_ipv4_adapters.first
+      adapter ? adapter.MACAddress : nil
+    end
+    module_function :macaddress
+  end
+end

data/vendored/facter/lib/facter/util/macosx.rb

@@ -0,0 +1,73 @@
+## macosx.rb
+## Support methods for Apple OSX facts
+##
+## Copyright (C) 2007 Jeff McCune
+## Author: Jeff McCune <jeff.mccune@northstarlabs.net>
+##
+
+module Facter::Util::Macosx
+  require 'cfpropertylist'
+  require 'facter/util/resolution'
+
+  Plist_Xml_Doctype  = '<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
+
+  # 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.profiler_xml(data_field)
+    Facter::Core::Execution.exec("/usr/sbin/system_profiler -xml #{data_field} 2>/dev/null")
+  end
+
+  def self.intern_xml(xml)
+    return nil unless xml
+    bad_xml_doctype = /^.*<!DOCTYPE plist PUBLIC -\/\/Apple Computer.*$/
+    if xml =~ bad_xml_doctype
+      xml.gsub!( bad_xml_doctype, Plist_Xml_Doctype )
+      Facter.debug("Had to fix plist with incorrect DOCTYPE declaration")
+    end
+    plist = CFPropertyList::List.new
+    begin
+      plist.load_str(xml)
+    rescue CFFormatError => e
+      raise RuntimeError, "A plist file could not be properly read by CFPropertyList: #{e.message}", e.backtrace
+    end
+    CFPropertyList.native_types(plist.value)
+  end
+
+  # Return an xml result, modified as we need it.
+  def self.profiler_data(data_field)
+    begin
+      return nil unless parsed_xml = intern_xml(profiler_xml(data_field))
+      return nil unless data = parsed_xml[0]['_items'][0]
+      data.delete '_name'
+      data
+    rescue
+      return nil
+    end
+  end
+
+  def self.hardware_overview
+    profiler_data("SPHardwareDataType")
+  end
+
+  def self.os_overview
+    profiler_data("SPSoftwareDataType")
+  end
+
+  def self.sw_vers
+    ver = Hash.new
+    [ "productName", "productVersion", "buildVersion" ].each do |option|
+      ver["macosx_#{option}"] = Facter::Core::Execution.exec("/usr/bin/sw_vers -#{option}").strip
+    end
+    productversion = ver["macosx_productVersion"]
+    if not productversion.nil?
+      versions = productversion.scan(/(\d+)\.(\d+)\.*(\d*)/)[0]
+      ver["macosx_productversion_major"] = "#{versions[0]}.#{versions[1]}"
+      if versions[2].empty?  # 10.x should be treated as 10.x.0
+        versions[2] = "0"
+      end
+      ver["macosx_productversion_minor"] = versions[2]
+    end
+    ver
+  end
+end

data/vendored/facter/lib/facter/util/manufacturer.rb

@@ -0,0 +1,99 @@
+# mamufacturer.rb
+# Support methods for manufacturer specific facts
+
+require 'facter/util/posix'
+
+module Facter::Manufacturer
+  def self.get_dmi_table()
+    case Facter.value(:kernel)
+    when 'Linux', 'GNU/kFreeBSD'
+      cmd = '/usr/sbin/dmidecode'
+    when 'FreeBSD'
+      cmd = '/usr/local/sbin/dmidecode'
+    when 'NetBSD', 'DragonFly'
+      cmd = '/usr/pkg/sbin/dmidecode'
+    when 'SunOS'
+      cmd = '/usr/sbin/smbios'
+    end
+
+    if cmd and (output = Facter::Core::Execution.exec("#{cmd} 2>/dev/null"))
+
+      if output.respond_to?(:force_encoding)
+        output.force_encoding(Encoding::ASCII_8BIT)
+      end
+
+      return output
+    end
+  end
+
+  def self.dmi_find_system_info(name)
+    splitstr=  Facter.value(:kernel) ==  'SunOS' ? "ID  SIZE TYPE" : /^Handle/
+    output = self.get_dmi_table()
+    return if output.nil?
+    name.each_pair do |key,v|
+      v.each do |v2|
+        v2.each_pair do |value,facterkey|
+          output.split(splitstr).each do |line|
+            if line =~ /#{key}/ and line =~ /\n\s+#{value} (.+)\n/
+              result = $1.strip
+              Facter.add(facterkey) do
+                confine :kernel => [ :linux, :freebsd, :netbsd, :sunos, :"gnu/kfreebsd", :dragonfly ]
+                setcode do
+                  result
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def self.sysctl_find_system_info(name)
+    name.each do |sysctlkey,facterkey|
+      Facter.add(facterkey) do
+        confine :kernel => [:openbsd, :darwin]
+        setcode { Facter::Util::POSIX.sysctl(sysctlkey) }
+      end
+    end
+  end
+
+  def self.prtdiag_sparc_find_system_info()
+    # Parses prtdiag for a SPARC architecture string, won't work with Solaris x86
+    output = Facter::Core::Execution.exec('/usr/sbin/prtdiag 2>/dev/null | /usr/bin/head -n 10')
+
+    # System Configuration:  Sun Microsystems  sun4u Sun SPARC Enterprise M3000 Server
+    if output and output =~ /^System Configuration:\s+(.+?)\s+(sun\d+\S+)\s+(.+)/
+      Facter.add('manufacturer') do
+        setcode do
+          $1
+        end
+      end
+      Facter.add('productname') do
+        setcode do
+          $3
+        end
+      end
+    end
+
+    Facter.add('serialnumber') do
+      setcode "/usr/sbin/sneep"
+    end
+  end
+
+  def self.win32_find_system_info(name)
+    require 'facter/util/wmi'
+    value = ""
+    wmi = Facter::Util::WMI.connect()
+    name.each do |facterkey, win32key|
+      query = wmi.ExecQuery("select * from Win32_#{win32key.last}")
+      Facter.add(facterkey) do
+        confine :kernel => :windows
+        setcode do
+          query.each { |x| value = x.__send__( (win32key.first).to_sym) }
+          value
+        end
+      end
+    end
+  end
+end

data/vendored/facter/lib/facter/util/memory.rb

@@ -0,0 +1,228 @@
+## memory.rb
+## Support module for memory related facts
+##
+
+require 'facter/util/posix'
+
+module Facter::Memory
+  def self.meminfo_number(tag)
+    memsize = ""
+    size = [0]
+    File.readlines("/proc/meminfo").each do |l|
+      size = $1.to_f if l =~ /^#{tag}:\s+(\d+)\s+\S+/
+      if tag == "MemFree" &&
+          l =~ /^(?:Buffers|Cached):\s+(\d+)\s+\S+/
+        size += $1.to_f
+      end
+    end
+    size / 1024.0
+  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
+
+    "%.2f %s" % [size, s]
+  end
+
+  def self.vmstat_find_free_memory(args = [])
+    cmd = 'vmstat'
+    cmd += (' ' + args.join(' ')) unless args.empty?
+    row = Facter::Core::Execution.exec(cmd).split("\n")[-1]
+    if row =~ /^\s*\d+\s*\d+\s*\d+\s*\d+\s*(\d+)/
+      memfree = $1
+    end
+  end
+
+  # Darwin had to be different. It's generally opaque with how much RAM it is
+  # using, and this figure could be improved upon too I fear.
+  # Parses the output of "vm_stat", takes the pages free & pages speculative
+  # and multiples that by the page size (also given in output). Ties in with
+  # what activity monitor outputs for free memory.
+  def self.vmstat_darwin_find_free_memory()
+
+    memfree = 0
+    pagesize = 0
+    memspecfree = 0
+
+    vmstats = Facter::Core::Execution.exec('vm_stat')
+    vmstats.each_line do |vmline|
+      case
+      when vmline =~ /page\ssize\sof\s(\d+)\sbytes/
+        pagesize = $1.to_i
+      when vmline =~ /^Pages\sfree:\s+(\d+)\./
+        memfree = $1.to_i
+      when vmline =~ /^Pages\sspeculative:\s+(\d+)\./
+        memspecfree = $1.to_i
+      end
+    end
+
+    freemem = ( memfree + memspecfree ) * pagesize
+  end
+
+  # on AIX use svmon to get the free memory:
+  # it's the third value on the line starting with memory
+  # svmon can be run by non root users
+  def self.svmon_aix_find_free_memory()
+    Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+\d+\s+\d+\s+(\d+)\s+/
+    $1
+  end
+
+  def self.mem_free(kernel = Facter.value(:kernel))
+    output = mem_free_info(kernel)
+    scale_mem_free_value output, kernel
+  end
+
+  def self.mem_free_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /OpenBSD/i, /SunOS/i, /Dragonfly/i
+      vmstat_find_free_memory()
+    when /FreeBSD/i
+      vmstat_find_free_memory(["-H"])
+    when /Darwin/i
+      vmstat_darwin_find_free_memory()
+    when /AIX/i
+      svmon_aix_find_free_memory()
+    end
+  end
+
+  def self.scale_mem_free_value (value, kernel)
+    case kernel
+    when /OpenBSD/i, /FreeBSD/i, /SunOS/i, /Dragonfly/i, /AIX/i
+      value.to_f / 1024.0
+    when /Darwin/i
+      value.to_f / 1024.0 / 1024.0
+    else
+      value.to_f
+    end
+ end
+
+  def self.mem_size(kernel = Facter.value(:kernel))
+    output = mem_size_info(kernel)
+    scale_mem_size_value output, kernel
+  end
+
+  def self.mem_size_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /Dragonfly/i, /FreeBSD/i, /OpenBSD/i
+      Facter::Util::POSIX.sysctl("hw.physmem")
+    when /Darwin/i
+      Facter::Util::POSIX.sysctl("hw.memsize")
+    when /AIX/i
+      if Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+(\d+)\s+/
+        $1
+      end
+    end
+  end
+
+  def self.scale_mem_size_value(value, kernel)
+    case kernel
+    when /OpenBSD/i, /FreeBSD/i, /Darwin/i, /Dragonfly/i
+      value.to_f / 1024.0 / 1024.0
+    when /AIX/i
+      value.to_f / 1024.0
+    else
+      value.to_f
+    end
+  end
+
+  def self.swap_size(kernel = Facter.value(:kernel))
+    output = swap_info(kernel)
+    parse_swap output, kernel, :size if output
+  end
+
+  def self.swap_free(kernel = Facter.value(:kernel))
+    output = swap_info(kernel)
+    parse_swap output, kernel, :free if output
+  end
+
+  def self.swap_info(kernel = Facter.value(:kernel))
+    case kernel
+    when /AIX/i
+      (Facter.value(:id) == "root") ? Facter::Core::Execution.exec('swap -l 2>/dev/null') : nil
+    when /OpenBSD/i
+      Facter::Core::Execution.exec('swapctl -s 2>/dev/null')
+    when /FreeBSD/i
+      Facter::Core::Execution.exec('swapinfo -k')
+    when /Darwin/i
+      Facter::Util::POSIX.sysctl('vm.swapusage')
+    when /SunOS/i
+      Facter::Core::Execution.exec('/usr/sbin/swap -l 2>/dev/null')
+    end
+  end
+
+  def self.parse_swap (output, kernel = Facter.value(:kernel), size_or_free = :size)
+    value_in_mb = 0.0
+    value = 0
+    is_size = size_or_free == :size
+    unless output.nil?
+      output.each_line do |line|
+        value += parse_swap_line(line, kernel, is_size)
+      end
+    end      
+    value_in_mb = scale_swap_value(value, kernel)
+  end
+
+  # There is a lot of duplication here because of concern over being able to add
+  # new platforms in a reasonable manner. For all of these platforms the first
+  # regex corresponds to the swap size value and the second corresponds to the swap
+  # free value, but this may not always be the case. In Ruby 1.9.3 it is possible
+  # to give these names, but sadly 1.8.7 does not support this.
+ 
+  def self.parse_swap_line(line, kernel, is_size)
+    case kernel
+    when /AIX/i
+      if line =~ /^\/\S+\s.*\s+(\S+)MB\s+(\S+)MB/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /OpenBSD/i
+      if line =~ /^total: (\d+) (\d+)-blocks allocated, (\d+) used, (\d+) available$/
+        (is_size) ? ($1.to_i * $2.to_i) : ($4.to_i * $2.to_i)
+      else
+        0
+      end
+    when /FreeBSD/i
+      if line =~ /\S+\s+(\d+)\s+\d+\s+(\d+)\s+\d+%$/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /Darwin/i
+      if line =~ /total\s=\s(\S+)M\s+used\s=\s\S+M\s+free\s=\s(\S+)M\s/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    when /SunOS/i
+      if line =~ /^\S+\s.*\s+(\d+)\s+(\d+)$/
+        (is_size) ? $1.to_i : $2.to_i
+      else
+        0
+      end
+    end
+  end
+
+  def self.scale_swap_value(value, kernel)
+    case kernel
+    when /FreeBSD/i
+      value.to_f / 1024.0
+    when /OpenBSD/i
+      value.to_f / 1024.0 / 1024.0
+    when /SunOS/i
+      value.to_f / 2 / 1024.0
+    else
+      value.to_f
+    end
+  end
+end