facter 2.1.0-x64-mingw32

data/lib/facter/util/ip/windows.rb

@@ -0,0 +1,215 @@
+# encoding: UTF-8
+
+require 'facter/util/wmi'
+require 'facter/util/ip'
+
+class Facter::Util::IP::Windows
+  # The WMI query used to return ip information
+  #
+  # @return [String]
+  #
+  # @api private
+  WMI_IP_INFO_QUERY = 'SELECT Description, ServiceName, IPAddress, IPConnectionMetric, InterfaceIndex, Index, IPSubnet, MACAddress, MTU, SettingID FROM Win32_NetworkAdapterConfiguration WHERE IPConnectionMetric IS NOT NULL AND IPEnabled = TRUE'
+
+  # Mapping fact names to WMI properties of the Win32_NetworkAdapterConfiguration
+  #
+  # @api private
+  WINDOWS_LABEL_WMI_MAP = {
+      :ipaddress => 'IPAddress',
+      :ipaddress6 => 'IPAddress',
+      :macaddress => 'MACAddress',
+      :netmask => 'IPSubnet'
+  }
+
+  def self.to_s
+    'windows'
+  end
+
+  # Windows doesn't display netmask in hex.
+  #
+  # @return [Boolean] false by default
+  #
+  # @api private
+  def self.convert_netmask_from_hex?
+    false
+  end
+
+  # Retrieves a list of unique interfaces names.
+  #
+  # @return [Array<String>]
+  #
+  # @api private
+  def self.interfaces
+    interface_names = []
+
+    network_adapter_configurations.map do |nic|
+      Facter::Util::WMI.execquery("SELECT * FROM Win32_NetworkAdapter WHERE Index = #{nic.Index} AND NetEnabled = TRUE").each do |nic|
+        interface_names << nic.NetConnectionId unless nic.NetConnectionId.nil? or nic.NetConnectionId.empty?
+      end
+    end
+
+    interface_names.uniq
+  end
+
+  # Get the value of an interface and label. For example, you may want to find
+  # the MTU for eth0.
+  #
+  # @param [String] interface the name of the interface returned by the {#interfaces} method.
+  # @param [String] label the type of value to return, e.g. ipaddress
+  # @return [String] the value, or nil if not defined
+  #
+  # @api private
+  def self.value_for_interface_and_label(interface, label)
+    wmi_value = WINDOWS_LABEL_WMI_MAP[label.downcase.to_sym]
+    label_value = nil
+    Facter::Util::WMI.execquery("SELECT Index FROM Win32_NetworkAdapter WHERE NetConnectionID = '#{interface}'").each do |nic|
+      Facter::Util::WMI.execquery("SELECT #{wmi_value} FROM Win32_NetworkAdapterConfiguration WHERE Index = #{nic.Index}").each do |nic_config|
+        case label.downcase.to_sym
+        when :ipaddress
+          nic_config.IPAddress.any? do |addr|
+            label_value = addr if valid_ipv4_address?(addr)
+            label_value
+          end
+        when :ipaddress6
+          nic_config.IPAddress.any? do |addr|
+            label_value = addr if Facter::Util::IP::Windows.valid_ipv6_address?(addr)
+            label_value
+          end
+        when :netmask
+          nic_config.IPSubnet.any? do |addr|
+            label_value = addr if Facter::Util::IP::Windows.valid_ipv4_address?(addr)
+            label_value
+          end
+        when :macaddress
+          label_value = nic_config.MACAddress
+        end
+      end
+    end
+
+    label_value
+  end
+
+  # Returns an array of partial Win32_NetworkAdapterConfiguration objects.
+  #
+  # @return [Array<WIN32OLE>] objects
+  #
+  # @api private
+  def self.network_adapter_configurations
+    nics = []
+    # WIN32OLE doesn't implement Enumerable
+    Facter::Util::WMI.execquery(WMI_IP_INFO_QUERY).each do |nic|
+      nics << nic
+    end
+    nics
+  end
+
+  # Gets a list of active IPv4 network adapter configurations sorted by the
+  # lowest IP connection metric. If two configurations have the same metric,
+  # then the IPv4 specific binding order as specified in the registry will
+  # be used.
+  #
+  # @return [Array<WIN32OLE>]
+  #
+  # @api private
+  def self.get_preferred_ipv4_adapters
+    get_preferred_network_adapters(Bindings4.new)
+  end
+
+  # Gets a list of active IPv6 network adapter configurations sorted by the
+  # lowest IP connection metric. If two configurations have the same metric,
+  # then the IPv6 specific binding order as specified in the registry will
+  # be used.
+  #
+  # @return [Array<WIN32OLE>]
+  #
+  # @api private
+  def self.get_preferred_ipv6_adapters
+    get_preferred_network_adapters(Bindings6.new)
+  end
+
+  # Gets a list of active network adapter configurations sorted by the lowest
+  # IP connection metric. If two configurations have the same metric, then
+  # the adapter binding order as specified in the registry will be used.
+  # Note the order may different for IPv4 vs IPv6 addresses.
+  #
+  # @see http://support.microsoft.com/kb/894564
+  # @return [Array<WIN32OLE>]
+  #
+  # @api private
+  def self.get_preferred_network_adapters(bindings)
+    network_adapter_configurations.select do |nic|
+      bindings.bindings.include?(nic.SettingID)
+    end.sort do |nic_left,nic_right|
+      cmp = nic_left.IPConnectionMetric <=> nic_right.IPConnectionMetric
+      if cmp == 0
+        bindings.bindings[nic_left.SettingID] <=> bindings.bindings[nic_right.SettingID]
+      else
+        cmp
+      end
+    end
+  end
+
+  class Bindings4
+    def initialize
+      @key = 'SYSTEM\CurrentControlSet\Services\Tcpip\Linkage'
+    end
+
+    def bindings
+      require 'facter/util/registry'
+      bindings = {}
+
+      Facter::Util::Registry.hklm_read(@key, 'Bind').each_with_index do |entry, index|
+        match_data = entry.match(/\\Device\\(\{.*\})/)
+        unless match_data.nil?
+          bindings[match_data[1]] = index
+        end
+      end
+
+      bindings
+    rescue
+      {}
+    end
+  end
+
+  class Bindings6 < Bindings4
+    def initialize
+      @key = 'SYSTEM\CurrentControlSet\Services\Tcpip6\Linkage'
+    end
+  end
+
+  # Determines if the value passed in is a valid ipv4 address.
+  #
+  # @param [String] ip_address the IPv4 address to validate
+  # @return [Boolean]
+  #
+  # @api private
+  def self.valid_ipv4_address?(ip_address)
+    String(ip_address).scan(/(?:[0-9]{1,3}\.){3}[0-9]{1,3}/).each do |match|
+      # excluding 169.254.x.x in Windows - this is the DHCP APIPA
+      #  meaning that if the node cannot get an ip address from the dhcp server,
+      #  it auto-assigns a private ip address
+      unless match == "127.0.0.1" or match =~ /^169.254.*/
+        return !!match
+      end
+    end
+
+    false
+  end
+
+  # Determines if the value passed in is a valid ipv6 address.
+  #
+  # @param [String] ip_address the IPv6 address to validate
+  # @return [Boolean]
+  #
+  # @api private
+  def self.valid_ipv6_address?(ip_address)
+    String(ip_address).scan(/(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4}/).each do |match|
+      unless match =~ /fe80.*/ or match == "::1"
+        return !!match
+      end
+    end
+
+    false
+  end
+
+end

data/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/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/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}")
+  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