facter 2.1.0-x64-mingw32

data/lib/facter/util/ec2.rb

@@ -0,0 +1,106 @@
+require 'timeout'
+require 'open-uri'
+
+# Provide a set of utility static methods that help with resolving the EC2
+# fact.
+module Facter::Util::EC2
+  class << self
+    # Test if we can connect to the EC2 api. Return true if able to connect.
+    # On failure this function fails silently and returns false.
+    #
+    # The +wait_sec+ parameter provides you with an adjustable timeout.
+    #
+    def can_connect?(wait_sec=2)
+      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
+      url = "http://169.254.169.254:80/"
+      Timeout::timeout(wait_sec) {open(url)}
+      return true
+    rescue Timeout::Error
+      return false
+    rescue
+      return false
+    end
+
+    # Test if this host has a mac address used by Eucalyptus clouds, which
+    # normally is +d0:0d+.
+    def has_euca_mac?
+      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
+      !!(Facter.value(:macaddress) =~ %r{^[dD]0:0[dD]:})
+    end
+
+    # Test if this host has a mac address used by OpenStack, which
+    # normally starts with FA:16:3E (older versions of OpenStack
+    # may generate mac addresses starting with 02:16:3E)
+    def has_openstack_mac?
+      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
+      !!(Facter.value(:macaddress) =~ %r{^(02|[fF][aA]):16:3[eE]})
+    end
+
+    # Test if the host has an arp entry in its cache that matches the EC2 arp,
+    # which is normally +fe:ff:ff:ff:ff:ff+.
+    def has_ec2_arp?
+      Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
+      kernel = Facter.value(:kernel)
+
+      mac_address_re = case kernel
+                       when /Windows/i
+                         /fe-ff-ff-ff-ff-ff/i
+                       else
+                         /fe:ff:ff:ff:ff:ff/i
+                       end
+
+      arp_command = case kernel
+                    when /Windows/i, /SunOS/i
+                      "arp -a"
+                    else
+                      "arp -an"
+                    end
+
+      if arp_table = Facter::Core::Execution.exec(arp_command)
+        return true if arp_table.match(mac_address_re)
+      end
+      return false
+    end
+  end
+
+  ##
+  # userdata returns a single string containing the body of the response of the
+  # GET request for the URI http://169.254.169.254/latest/user-data/  If the
+  # metadata server responds with a 404 Not Found error code then this method
+  # retuns `nil`.
+  #
+  # @param version [String] containing the API version for the request.
+  # Defaults to "latest" and other examples are documented at
+  # http://aws.amazon.com/archives/Amazon%20EC2
+  #
+  # @api public
+  #
+  # @return [String] containing the response body or `nil`
+  def self.userdata(version="latest")
+    Facter.warnonce("#{self}.#{__method__} is deprecated; see the Facter::EC2 classes instead")
+    uri = "http://169.254.169.254/#{version}/user-data/"
+    begin
+      read_uri(uri)
+    rescue OpenURI::HTTPError => detail
+      case detail.message
+      when /404 Not Found/i
+        Facter.debug "No user-data present at #{uri}: server responded with #{detail.message}"
+        return nil
+      else
+        raise detail
+      end
+    end
+  end
+
+  ##
+  # read_uri provides a seam method to easily test the HTTP client
+  # functionality of a HTTP based metadata server.
+  #
+  # @api private
+  #
+  # @return [String] containing the body of the response
+  def self.read_uri(uri)
+    open(uri).read
+  end
+  private_class_method :read_uri
+end

data/lib/facter/util/fact.rb

@@ -0,0 +1,204 @@
+require 'facter'
+require 'facter/util/resolution'
+require 'facter/core/aggregate'
+
+# This class represents a fact. Each fact has a name and multiple
+# {Facter::Util::Resolution resolutions}.
+#
+# Create facts using {Facter.add}
+#
+# @api public
+class Facter::Util::Fact
+  # The name of the fact
+  # @return [String]
+  attr_accessor :name
+
+  # @return [String]
+  # @deprecated
+  attr_accessor :ldapname
+
+  # Creates a new fact, with no resolution mechanisms. See {Facter.add}
+  # for the public API for creating facts.
+  # @param name [String] the fact name
+  # @param options [Hash] optional parameters
+  # @option options [String] :ldapname set the ldapname property on the fact
+  #
+  # @api private
+  def initialize(name, options = {})
+    @name = name.to_s.downcase.intern
+
+    extract_ldapname_option!(options)
+
+    @ldapname ||= @name.to_s
+
+    @resolves = []
+    @searching = false
+
+    @value = nil
+  end
+
+  # Adds a new {Facter::Util::Resolution resolution}.  This requires a
+  # block, which will then be evaluated in the context of the new
+  # resolution.
+  #
+  # @param options [Hash] A hash of options to set on the resolution
+  #
+  # @return [Facter::Util::Resolution]
+  #
+  # @api private
+  def add(options = {}, &block)
+    define_resolution(nil, options, &block)
+  end
+
+  # Define a new named resolution or return an existing resolution with
+  # the given name.
+  #
+  # @param resolution_name [String] The name of the resolve to define or look up
+  # @param options [Hash] A hash of options to set on the resolution
+  # @return [Facter::Util::Resolution]
+  #
+  # @api public
+  def define_resolution(resolution_name, options = {}, &block)
+
+    resolution_type = options.delete(:type) || :simple
+
+    resolve = create_or_return_resolution(resolution_name, resolution_type)
+
+    resolve.set_options(options) unless options.empty?
+    resolve.evaluate(&block) if block
+
+    resolve
+  rescue => e
+    Facter.log_exception(e, "Unable to add resolve #{resolution_name.inspect} for fact #{@name}: #{e.message}")
+  end
+
+  # Retrieve an existing resolution by name
+  #
+  # @param name [String]
+  #
+  # @return [Facter::Util::Resolution, nil] The resolution if exists, nil if
+  #   it doesn't exist or name is nil
+  def resolution(name)
+    return nil if name.nil?
+
+    @resolves.find { |resolve| resolve.name == name }
+  end
+
+  # Flushes any cached values.
+  #
+  # @return [void]
+  #
+  # @api private
+  def flush
+    @resolves.each { |r| r.flush }
+    @value = nil
+  end
+
+  # Returns the value for this fact. This searches all resolutions by
+  # suitability and weight (see {Facter::Util::Resolution}). If no
+  # suitable resolution is found, it returns nil.
+  #
+  # @api public
+  def value
+    return @value if @value
+
+    if @resolves.empty?
+      Facter.debug "No resolves for %s" % @name
+      return nil
+    end
+
+    searching do
+
+      suitable_resolutions = sort_by_weight(find_suitable_resolutions(@resolves))
+      @value = find_first_real_value(suitable_resolutions)
+
+      announce_when_no_suitable_resolution(suitable_resolutions)
+      announce_when_no_value_found(@value)
+
+      @value
+    end
+  end
+
+  # @api private
+  # @deprecated
+  def extract_ldapname_option!(options)
+    if options[:ldapname]
+      Facter.warnonce("ldapname is deprecated and will be removed in a future version")
+      self.ldapname = options.delete(:ldapname)
+    end
+  end
+
+  private
+
+  # Are we in the midst of a search?
+  def searching?
+    @searching
+  end
+
+  # Lock our searching process, so we never ge stuck in recursion.
+  def searching
+    raise RuntimeError, "Caught recursion on #{@name}" if searching?
+
+    # If we've gotten this far, we're not already searching, so go ahead and do so.
+    @searching = true
+    begin
+      yield
+    ensure
+      @searching = false
+    end
+  end
+
+  def find_suitable_resolutions(resolutions)
+    resolutions.find_all{ |resolve| resolve.suitable? }
+  end
+
+  def sort_by_weight(resolutions)
+    resolutions.sort { |a, b| b.weight <=> a.weight }
+  end
+
+  def find_first_real_value(resolutions)
+    resolutions.each do |resolve|
+      value = resolve.value
+      if not value.nil?
+        return value
+      end
+    end
+    nil
+  end
+
+  def announce_when_no_suitable_resolution(resolutions)
+    if resolutions.empty?
+      Facter.debug "Found no suitable resolves of %s for %s" % [@resolves.length, @name]
+    end
+  end
+
+  def announce_when_no_value_found(value)
+    if value.nil?
+      Facter.debug("value for %s is still nil" % @name)
+    end
+  end
+
+  def create_or_return_resolution(resolution_name, resolution_type)
+    resolve = self.resolution(resolution_name)
+
+    if resolve
+      if resolution_type != resolve.resolution_type
+        raise ArgumentError, "Cannot return resolution #{resolution_name} with type" +
+          " #{resolution_type}; already defined as #{resolve.resolution_type}"
+      end
+    else
+      case resolution_type
+      when :simple
+        resolve = Facter::Util::Resolution.new(resolution_name, self)
+      when :aggregate
+        resolve = Facter::Core::Aggregate.new(resolution_name, self)
+      else
+        raise ArgumentError, "Expected resolution type to be one of (:simple, :aggregate) but was #{resolution_type}"
+      end
+
+      @resolves << resolve
+    end
+
+    resolve
+  end
+end

data/lib/facter/util/file_read.rb

@@ -0,0 +1,37 @@
+module Facter
+module Util
+
+# {Facter::Util::FileRead} is a utility module intended to provide easily
+# mockable methods that delegate to simple file read methods.  The intent is to
+# avoid the need to execute the `cat` system command or `File.read` directly in
+# Ruby, as mocking these behaviors can have wide-ranging effects.
+#
+# All Facter facts are encouraged to use this method instead of File.read or
+# Facter::Core::Execution.exec('cat ...')
+#
+# @api public
+module FileRead
+  # read returns the raw content of a file as a string.  If the file does not
+  # exist, or the process does not have permission to read the file then nil is
+  # returned.
+  #
+  # @api public
+  #
+  # @param path [String] the path to be read
+  #
+  # @return [String, nil] the raw contents of the file or `nil` if the
+  #   file cannot be read because it does not exist or the process does not have
+  #   permission to read the file.
+  def self.read(path)
+    File.read(path)
+  rescue Errno::ENOENT, Errno::EACCES => detail
+    Facter.debug "Could not read #{path}: #{detail.message}"
+    nil
+  end
+
+  def self.read_binary(path)
+    File.open(path, "rb") { |contents| contents.read }
+  end
+end
+end
+end

data/lib/facter/util/formatter.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+
+module Facter
+  module Util
+    module Formatter
+
+      def self.format_json(hash)
+        if Facter.json?
+          JSON.pretty_generate(hash)
+        else
+          raise "Cannot format facts as JSON; 'json' library is not present"
+        end
+      end
+
+      def self.format_yaml(hash)
+        YAML.dump(hash)
+      end
+
+      def self.format_plaintext(hash)
+        output = ''
+
+        # Print the value of a single fact, otherwise print a list sorted by fact
+        # name and separated by "=>"
+        if hash.length == 1
+          if value = hash.values.first
+            output = value.is_a?(String) ? value : value.inspect
+          end
+        else
+          hash.sort_by { |(name, value)| name }.each do |name,value|
+            value = value.is_a?(String) ? value : value.inspect
+            output << "#{name} => #{value}\n"
+          end
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/facter/util/ip.rb

@@ -0,0 +1,285 @@
+# A base module for collecting IP-related
+# information from all kinds of platforms.
+module Facter::Util::IP
+  # A map of all the different regexes that work for
+  # a given platform or set of platforms.
+  REGEX_MAP = {
+    :linux => {
+      :ipaddress  => /inet (?:addr:)?([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
+      :ipaddress6 => /inet6 (?:addr: )?((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
+      :macaddress => /(?:ether|HWaddr)\s+((\w{1,2}:){5,}\w{1,2})/,
+      :netmask  => /(?:Mask:|netmask )([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
+      :mtu  => /MTU:?\s*(\d+)/i
+    },
+    :bsd   => {
+      :aliases  => [:openbsd, :netbsd, :freebsd, :darwin, :"gnu/kfreebsd", :dragonfly],
+      :ipaddress  => /inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
+      :ipaddress6 => /inet6 ((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
+      :macaddress => /(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/,
+      :netmask  => /netmask\s+0x(\w{8})/,
+      :mtu => /mtu\s+(\d+)/
+    },
+    :sunos => {
+      :ipaddress  => /inet\s+([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)/,
+      :ipaddress6 => /inet6 ((?![fe80|::1])(?>[0-9,a-f,A-F]*\:{1,2})+[0-9,a-f,A-F]{0,4})/,
+      :macaddress => /(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/,
+      :netmask  => /netmask\s+(\w{8})/,
+      :mtu => /mtu\s+(\d+)/
+    },
+    :"hp-ux" => {
+      :ipaddress  => /\s+inet (\S+)\s.*/,
+      :macaddress => /(\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2}:\w{1,2})/,
+      :netmask  => /.*\s+netmask (\S+)\s.*/
+    },
+    :windows => {}
+  }
+
+  # Convert an interface name into purely alphanumeric characters.
+  def self.alphafy(interface)
+    interface.gsub(/[^a-z0-9_]/i, '_')
+  end
+
+  def self.convert_from_hex?(kernel)
+    kernels_to_convert = [:sunos, :openbsd, :netbsd, :freebsd, :darwin, :"hp-ux", :"gnu/kfreebsd", :dragonfly]
+    kernels_to_convert.include?(kernel)
+  end
+
+  def self.supported_platforms
+    REGEX_MAP.inject([]) do |result, tmp|
+      key, map = tmp
+      if map[:aliases]
+        result += map[:aliases]
+      else
+        result << key
+      end
+      result
+    end
+  end
+
+  def self.get_interfaces
+    if Facter.value(:kernel) == 'windows'
+      require 'facter/util/ip/windows'
+      return Facter::Util::IP::Windows.interfaces
+    end
+
+    return [] unless output = Facter::Util::IP.get_all_interface_output()
+
+    # Our regex appears to be stupid, in that it leaves colons sitting
+    # at the end of interfaces.  So, we have to trim those trailing
+    # characters.  I tried making the regex better but supporting all
+    # platforms with a single regex is probably a bit too much.
+    output.scan(/^\S+/).collect { |i| i.sub(/:$/, '') }.uniq
+  end
+
+  def self.get_all_interface_output
+    case Facter.value(:kernel)
+    when 'Linux', 'OpenBSD', 'NetBSD', 'FreeBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly'
+      output = Facter::Util::IP.exec_ifconfig(["-a","2>/dev/null"])
+    when 'SunOS'
+      output = Facter::Util::IP.exec_ifconfig(["-a"])
+    when 'HP-UX'
+      # (#17487)[https://projects.puppetlabs.com/issues/17487]
+      # Handle NIC bonding where asterisks and virtual NICs are printed.
+      if output = hpux_netstat_in
+        output.gsub!(/\*/, "")                  # delete asterisks.
+        output.gsub!(/^[^\n]*none[^\n]*\n/, "") # delete lines with 'none' instead of IPs.
+        output.sub!(/^[^\n]*\n/, "")            # delete the header line.
+        output
+      end
+    end
+    output
+  end
+
+
+  ##
+  # exec_ifconfig uses the ifconfig command
+  #
+  # @return [String] the output of `ifconfig #{arguments} 2>/dev/null` or nil
+  def self.exec_ifconfig(additional_arguments=[])
+    Facter::Core::Execution.exec("#{self.get_ifconfig} #{additional_arguments.join(' ')}")
+  end
+  ##
+  # get_ifconfig looks up the ifconfig binary
+  #
+  # @return [String] path to the ifconfig binary
+  def self.get_ifconfig
+    common_paths=["/bin/ifconfig","/sbin/ifconfig","/usr/sbin/ifconfig"]
+    common_paths.select{|path| File.executable?(path)}.first
+  end
+  ##
+  # hpux_netstat_in is a delegate method that allows us to stub netstat -in
+  # without stubbing exec.
+  def self.hpux_netstat_in
+    Facter::Core::Execution.exec("/bin/netstat -in")
+  end
+
+  def self.get_infiniband_macaddress(interface)
+    if File.exists?("/sys/class/net/#{interface}/address") then
+      ib_mac_address = `cat /sys/class/net/#{interface}/address`.chomp
+    elsif File.exists?("/sbin/ip") then
+      ip_output = %x{/sbin/ip link show #{interface}}
+      ib_mac_address = ip_output.scan(%r{infiniband\s+((\w{1,2}:){5,}\w{1,2})})
+    else
+      ib_mac_address = "FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF:FF"
+      Facter.debug("ip.rb: nothing under /sys/class/net/#{interface}/address and /sbin/ip not available")
+    end
+    ib_mac_address
+  end
+
+  def self.ifconfig_interface(interface)
+    output = Facter::Util::IP.exec_ifconfig([interface,"2>/dev/null"])
+  end
+
+  def self.get_single_interface_output(interface)
+    output = ""
+    case Facter.value(:kernel)
+    when 'OpenBSD', 'NetBSD', 'FreeBSD', 'Darwin', 'GNU/kFreeBSD', 'DragonFly'
+      output = Facter::Util::IP.ifconfig_interface(interface)
+    when 'Linux'
+      ifconfig_output = Facter::Util::IP.ifconfig_interface(interface)
+      if interface =~ /^ib/ then
+        real_mac_address = get_infiniband_macaddress(interface)
+        output = ifconfig_output.sub(%r{(?:ether|HWaddr)\s+((\w{1,2}:){5,}\w{1,2})}, "HWaddr #{real_mac_address}")
+      else
+        output = ifconfig_output
+      end
+    when 'SunOS'
+      output = Facter::Util::IP.exec_ifconfig([interface])
+    when 'HP-UX'
+       mac = ""
+       ifc = hpux_ifconfig_interface(interface)
+       hpux_lanscan.scan(/(\dx\S+).*UP\s+(\w+\d+)/).each {|i| mac = i[0] if i.include?(interface) }
+       mac = mac.sub(/0x(\S+)/,'\1').scan(/../).join(":")
+       output = ifc + "\n" + mac
+    end
+    output
+  end
+
+  def self.hpux_ifconfig_interface(interface)
+    Facter::Util::IP.exec_ifconfig([interface])
+  end
+
+  def self.hpux_lanscan
+    Facter::Core::Execution.exec("/usr/sbin/lanscan")
+  end
+
+  def self.get_output_for_interface_and_label(interface, label)
+    return get_single_interface_output(interface) unless Facter.value(:kernel) == 'windows'
+
+    require 'facter/util/ip/windows'
+    output = Facter::Util::IP::Windows.value_for_interface_and_label(interface, label)
+    output ? output : ""
+  end
+
+  def self.get_bonding_master(interface)
+    if Facter.value(:kernel) != 'Linux'
+      return nil
+    end
+    # We need ip instead of ifconfig because it will show us
+    # the bonding master device.
+    if not FileTest.executable?("/sbin/ip")
+      return nil
+    end
+    # A bonding interface can never be an alias interface. Alias
+    # interfaces do have a colon in their name and the ip link show
+    # command throws an error message when we pass it an alias
+    # interface.
+    if interface =~ /:/
+      return nil
+    end
+    regex = /SLAVE[,>].* (bond[0-9]+)/
+      ethbond = regex.match(%x{/sbin/ip link show #{interface}})
+    if ethbond
+      device = ethbond[1]
+    else
+      device = nil
+    end
+    device
+  end
+
+  ##
+  # get_interface_value obtains the value of a specific attribute of a specific
+  # interface.
+  #
+  # @param interface [String] the interface identifier, e.g. "eth0" or "bond0"
+  #
+  # @param label [String] the attribute of the interface to obtain a value for,
+  # e.g. "netmask" or "ipaddress"
+  #
+  # @api private
+  #
+  # @return [String] representing the requested value.  An empty array is
+  # returned if the kernel is not supported by the REGEX_MAP constant.
+  def self.get_interface_value(interface, label)
+    if Facter.value(:kernel) == 'windows'
+      require 'facter/util/ip/windows'
+      return Facter::Util::IP::Windows.value_for_interface_and_label(interface, label)
+    end
+
+    tmp1 = []
+
+    kernel = Facter.value(:kernel).downcase.to_sym
+
+    # If it's not directly in the map or aliased in the map, then we don't know how to deal with it.
+    unless map = REGEX_MAP[kernel] || REGEX_MAP.values.find { |tmp| tmp[:aliases] and tmp[:aliases].include?(kernel) }
+      return []
+    end
+
+    # Pull the correct regex out of the map.
+    regex = map[label.to_sym]
+
+    # Linux changes the MAC address reported via ifconfig when an ethernet interface
+    # becomes a slave of a bonding device to the master MAC address.
+    # We have to dig a bit to get the original/real MAC address of the interface.
+    bonddev = get_bonding_master(interface)
+    if label == 'macaddress' and bonddev
+      bondinfo = read_proc_net_bonding("/proc/net/bonding/#{bonddev}")
+      re = /^Slave Interface: #{interface}\b.*?\bPermanent HW addr: (([0-9A-F]{2}:?)*)$/im
+      if match = re.match(bondinfo)
+        value = match[1].upcase
+      end
+    else
+      output_int = get_output_for_interface_and_label(interface, label)
+
+      output_int.each_line do |s|
+        if s =~ regex
+          value = $1
+            if label == 'netmask' && convert_from_hex?(kernel)
+              value = value.scan(/../).collect do |byte| byte.to_i(16) end.join('.')
+            end
+          tmp1.push(value)
+        end
+      end
+
+      if tmp1
+        value = tmp1.shift
+      end
+    end
+  end
+
+  ##
+  # read_proc_net_bonding is a seam method for mocking purposes.
+  #
+  # @param path [String] representing the path to read, e.g. "/proc/net/bonding/bond0"
+  #
+  # @api private
+  #
+  # @return [String] modeling the raw file read
+  def self.read_proc_net_bonding(path)
+    File.read(path) if File.exists?(path)
+  end
+  private_class_method :read_proc_net_bonding
+
+  def self.get_network_value(interface)
+    require 'ipaddr'
+
+    ipaddress = get_interface_value(interface, "ipaddress")
+    netmask = get_interface_value(interface, "netmask")
+
+    if ipaddress && netmask
+      ip = IPAddr.new(ipaddress, Socket::AF_INET)
+      subnet = IPAddr.new(netmask, Socket::AF_INET)
+      network = ip.mask(subnet.to_s).to_s
+    end
+  end
+end