facter 2.5.7-x64-mingw32 → 3.9.6.cfacter.20180412-x64-mingw32

data/lib/facter/core/resolvable.rb

@@ -1,94 +0,0 @@
-require 'timeout'
-
-# The resolvable mixin defines behavior for evaluating and returning fact
-# resolutions.
-#
-# Classes including this mixin should implement at #name method describing
-# the value being resolved and a #resolve_value that actually executes the code
-# to resolve the value.
-module Facter::Core::Resolvable
-
-  # The timeout, in seconds, for evaluating this resolution.
-  # @return [Integer]
-  # @api public
-  attr_accessor :timeout
-
-  # Return the timeout period for resolving a value.
-  # (see #timeout)
-  # @return [Numeric]
-  # @comment requiring 'timeout' stdlib class causes Object#timeout to be
-  #   defined which delegates to Timeout.timeout. This method may potentially
-  #   overwrite the #timeout attr_reader on this class, so we define #limit to
-  #   avoid conflicts.
-  def limit
-    @timeout || 0
-  end
-
-  ##
-  # on_flush accepts a block and executes the block when the resolution's value
-  # is flushed.  This makes it possible to model a single, expensive system
-  # call inside of a Ruby object and then define multiple dynamic facts which
-  # resolve by sending messages to the model instance.  If one of the dynamic
-  # facts is flushed then it can, in turn, flush the data stored in the model
-  # instance to keep all of the dynamic facts in sync without making multiple,
-  # expensive, system calls.
-  #
-  # Please see the Solaris zones fact for an example of how this feature may be
-  # used.
-  #
-  # @see Facter::Util::Fact#flush
-  # @see Facter::Util::Resolution#flush
-  #
-  # @api public
-  def on_flush(&block)
-    @on_flush_block = block
-  end
-
-  ##
-  # flush executes the block, if any, stored by the {on_flush} method
-  #
-  # @see Facter::Util::Fact#flush
-  # @see Facter::Util::Resolution#on_flush
-  #
-  # @api private
-  def flush
-    @on_flush_block.call if @on_flush_block
-  end
-
-  def value
-    result = nil
-
-    with_timing do
-      Timeout.timeout(limit) do
-        result = resolve_value
-      end
-    end
-
-    Facter::Util::Normalization.normalize(result)
-  rescue Timeout::Error => detail
-    Facter.log_exception(detail, "Timed out after #{limit} seconds while resolving #{qualified_name}")
-    return nil
-  rescue Facter::Util::Normalization::NormalizationError => detail
-    Facter.log_exception(detail, "Fact resolution #{qualified_name} resolved to an invalid value: #{detail.message}")
-    return nil
-  rescue => detail
-    Facter.log_exception(detail, "Could not retrieve #{qualified_name}: #{detail.message}")
-    return nil
-  end
-
-  private
-
-  def with_timing
-    starttime = Time.now.to_f
-
-    yield
-
-    finishtime = Time.now.to_f
-    ms = (finishtime - starttime) * 1000
-    Facter.show_time "#{qualified_name}: #{"%.2f" % ms}ms"
-  end
-
-  def qualified_name
-    "fact='#{@fact.name.to_s}', resolution='#{@name || '<anonymous>'}'"
-  end
-end

data/lib/facter/core/suitable.rb

@@ -1,113 +0,0 @@
-require 'facter'
-
-# The Suitable mixin provides mechanisms for confining objects to run on
-# certain platforms and determining the run precedence of these objects.
-#
-# Classes that include the Suitable mixin should define a `#confines` method
-# that returns an Array of zero or more Facter::Util::Confine objects.
-module Facter::Core::Suitable
-
-  attr_writer :weight
-
-  # Sets the weight of this resolution. If multiple suitable resolutions
-  # are found, the one with the highest weight will be used.  If weight
-  # is not given, the number of confines set on a resolution will be
-  # used as its weight (so that the most specific resolution is used).
-  #
-  # @param weight [Integer] the weight of this resolution
-  #
-  # @return [void]
-  #
-  # @api public
-  def has_weight(weight)
-    @weight = weight
-  end
-
-  # Sets the conditions for this resolution to be used.  This method accepts
-  # multiple forms of arguments to determine suitability.
-  #
-  # @return [void]
-  #
-  # @api public
-  #
-  # @overload confine(confines)
-  #   Confine a fact to a specific fact value or values.  This form takes a
-  #   hash of fact names and values. Every fact must match the values given for
-  #   that fact, otherwise this resolution will not be considered suitable. The
-  #   values given for a fact can be an array, in which case the value of the
-  #   fact must be in the array for it to match.
-  #   @param [Hash{String,Symbol=>String,Array<String>}] confines set of facts identified by the hash keys whose
-  #     fact value must match the argument value.
-  #   @example Confining to Linux
-  #       Facter.add(:powerstates) do
-  #         # This resolution only makes sense on linux systems
-  #         confine :kernel => "Linux"
-  #         setcode do
-  #           File.read('/sys/power/states')
-  #         end
-  #       end
-  #
-  # @overload confine(confines, &block)
-  #   Confine a fact to a block with the value of a specified fact yielded to
-  #   the block.
-  #   @param [String,Symbol] confines the fact name whose value should be
-  #     yielded to the block
-  #   @param [Proc] block determines the suitability of the fact.  If the block
-  #     evaluates to `false` or `nil` then the confined fact will not be
-  #     evaluated.
-  #   @yield [value] the value of the fact identified by {confines}
-  #   @example Confine the fact to a host with an ipaddress in a specific
-  #     subnet
-  #       confine :ipaddress do |addr|
-  #         require 'ipaddr'
-  #         IPAddr.new('192.168.0.0/16').include? addr
-  #       end
-  #
-  # @overload confine(&block)
-  #   Confine a fact to a block.  The fact will be evaluated only if the block
-  #   evaluates to something other than `false` or `nil`.
-  #   @param [Proc] block determines the suitability of the fact.  If the block
-  #     evaluates to `false` or `nil` then the confined fact will not be
-  #     evaluated.
-  #   @example Confine the fact to systems with a specific file.
-  #       confine { File.exist? '/bin/foo' }
-  def confine(confines = nil, &block)
-    case confines
-    when Hash
-      confines.each do |fact, values|
-        @confines.push Facter::Util::Confine.new(fact, *values)
-      end
-    else
-      if block
-        if confines
-          @confines.push Facter::Util::Confine.new(confines, &block)
-        else
-          @confines.push Facter::Util::Confine.new(&block)
-        end
-      else
-      end
-    end
-  end
-
-  # Returns the importance of this resolution. If the weight was not
-  # given, the number of confines is used instead (so that a more
-  # specific resolution wins over a less specific one).
-  #
-  # @return [Integer] the weight of this resolution
-  #
-  # @api private
-  def weight
-    if @weight
-      @weight
-    else
-      @confines.length
-    end
-  end
-
-  # Is this resolution mechanism suitable on the system in question?
-  #
-  # @api private
-  def suitable?
-    @confines.all? { |confine| confine.true? }
-  end
-end

data/lib/facter/dhcp_servers.rb

@@ -1,45 +0,0 @@
-# Fact: dhcp_servers
-#
-# Purpose:
-#   Return the DHCP server addresses for all interfaces as a hash.
-#   If the interface that is the default gateway is DHCP assigned, there
-#   will also be a `"system"` entry in the hash.
-#
-#   This fact is structured. Values are returned as a group of key-value pairs.
-#
-# Resolution:
-#   Parses the output of `nmcli` to find the DHCP server for the interface if available.
-#
-# Caveats:
-#   Requires `nmcli` to be available and the interface must use network-manager.
-#
-
-require 'facter'
-require 'facter/util/dhcp_servers'
-
-
-Facter.add(:dhcp_servers) do
-  confine :kernel => :linux
-  confine do
-    Facter::Core::Execution.which('nmcli')
-  end
-  confine do
-    s = Facter::Util::DHCPServers.network_manager_state
-    !s.empty? && (s != 'unknown')
-  end
-
-  setcode do
-    gwdev   = Facter::Util::DHCPServers.gateway_device
-    devices = Facter::Util::DHCPServers.devices
-
-    dhcp_servers = {}
-    devices.each do |device|
-      if server = Facter::Util::DHCPServers.device_dhcp_server(device)
-        dhcp_servers['system'] = server if device == gwdev
-        dhcp_servers[device]   = server
-      end
-    end
-
-    dhcp_servers.keys.length > 0 ? dhcp_servers : nil
-  end
-end

data/lib/facter/domain.rb

@@ -1,99 +0,0 @@
-# Fact: domain
-#
-# Purpose:
-#   Return the host's primary DNS domain name.
-#
-# Resolution:
-#   On UNIX (excluding Darwin), first try and use the hostname fact,
-#   which uses the `hostname` system command, and then parse the output
-#   of that.
-#   Failing that, it tries the `dnsdomainname` system command.
-#   Failing that, it uses `/etc/resolv.conf` and takes the domain from that, or as
-#   a final resort, the search from that.
-#   Otherwise returns `nil`.
-#
-#   On Windows uses the win32ole gem and winmgmts to get the DNSDomain value
-#   from the Win32 networking stack.
-#
-# Caveats:
-#
-
-Facter.add(:domain) do
-  setcode do
-    # Get the domain from various sources; the order of these
-    # steps is important
-
-    # In some OS 'hostname -f' will change the hostname to '-f'
-    # We know that Solaris and HP-UX exhibit this behavior
-    # On good OS, 'hostname -f' will return the FQDN which is preferable
-    # Due to dangerous behavior of 'hostname -f' on old OS, we will explicitly opt-in
-    # 'hostname -f' --hkenney May 9, 2012
-    basic_hostname = 'hostname 2> /dev/null'
-    windows_hostname = 'hostname > NUL'
-    full_hostname = 'hostname -f 2> /dev/null'
-    can_do_hostname_f = Regexp.union /Linux/i, /FreeBSD/i, /Darwin/i
-
-    hostname_command = if Facter.value(:kernel) =~ can_do_hostname_f
-                         full_hostname
-                       elsif Facter.value(:kernel) == "windows"
-                         windows_hostname
-                       else
-                         basic_hostname
-                       end
-
-    if name = Facter::Core::Execution.exec(hostname_command) \
-      and name =~ /.*?\.(.+$)/
-
-      return_value = $1
-    elsif Facter.value(:kernel) != "windows" and domain = Facter::Core::Execution.exec('dnsdomainname 2> /dev/null') \
-      and domain =~ /.+/
-
-      return_value = domain
-    elsif FileTest.exists?("/etc/resolv.conf")
-      domain = nil
-      search = nil
-      File.open("/etc/resolv.conf") { |file|
-        file.each { |line|
-          if line =~ /^\s*domain\s+(\S+)/
-            domain = $1
-          elsif line =~ /^\s*search\s+(\S+)/
-            search = $1
-          end
-        }
-      }
-      return_value ||= domain
-      return_value ||= search
-    end
-
-    if return_value
-      return_value.gsub(/\.$/, '')
-    end
-  end
-end
-
-Facter.add(:domain) do
-  confine :kernel => :windows
-  setcode do
-    require 'facter/util/registry'
-
-    domain = nil
-    regvalue = Facter::Util::Registry.hklm_read('SYSTEM\CurrentControlSet\Services\Tcpip\Parameters', 'Domain')
-
-    if regvalue and not regvalue.empty?
-      domain = regvalue
-    else
-      require 'facter/util/wmi'
-      Facter::Util::WMI.execquery("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").each { |nic|
-        if nic.DNSDomain && nic.DNSDomain.length > 0
-          domain = nic.DNSDomain
-          break
-        end
-      }
-    end
-
-
-    if domain
-      domain.gsub(/\.$/, '')
-    end
-  end
-end

data/lib/facter/ec2.rb

@@ -1,68 +0,0 @@
-# Fact: ec2_<EC2 INSTANCE DATA>
-#
-# Purpose:
-#   Returns info retrieved in bulk from the EC2 API. The names of these facts
-#   should be self explanatory, and they are otherwise undocumented. The full
-#   list of these facts is: ec2_ami_id, ec2_ami_launch_index,
-#   ec2_ami_manifest_path, ec2_block_device_mapping_ami,
-#   ec2_block_device_mapping_ephemeral0, ec2_block_device_mapping_root,
-#   ec2_hostname, ec2_instance_id, ec2_instance_type, ec2_kernel_id,
-#   ec2_local_hostname, ec2_local_ipv4, ec2_placement_availability_zone,
-#   ec2_profile, ec2_public_hostname, ec2_public_ipv4,
-#   ec2_public_keys_0_openssh_key, ec2_reservation_id, and ec2_security_groups.
-#
-# Resolution:
-#   Directly queries the EC2 metadata endpoint.
-#
-
-require 'facter/ec2/rest' unless defined?(Facter::EC2)
-
-Facter.define_fact(:ec2_metadata) do
-  define_resolution(:rest) do
-    confine do
-      Facter.value(:virtual).match /^(xen|kvm|nitro|ec2)/
-    end
-
-    @querier = Facter::EC2::Metadata.new
-    confine do
-      @querier.reachable?
-    end
-
-    setcode do
-      @querier.fetch
-    end
-  end
-end
-
-Facter.define_fact(:ec2_userdata) do
-  define_resolution(:rest) do
-    confine do
-      Facter.value(:virtual).match /^(xen|kvm|nitro|ec2)/
-    end
-
-    @querier = Facter::EC2::Userdata.new
-    confine do
-      @querier.reachable?
-    end
-
-    setcode do
-      userdata = @querier.fetch
-      begin
-        Facter::Util::Normalization.normalize_string(userdata)
-      rescue Facter::Util::Normalization::NormalizationError => e
-        Facter.debug("Failed to read ec2 userdata: #{e.message}")
-        userdata = nil
-      end
-      userdata
-    end
-  end
-end
-
-# The flattened version of the EC2 facts are deprecated and will be removed in
-# a future release of Facter.
-if (ec2_metadata = Facter.value(:ec2_metadata))
-  ec2_facts = Facter::Util::Values.flatten_structure("ec2", ec2_metadata)
-  ec2_facts.each_pair do |factname, factvalue|
-    Facter.add(factname, :value => factvalue)
-  end
-end

data/lib/facter/ec2/rest.rb

@@ -1,137 +0,0 @@
-require 'timeout'
-require 'open-uri'
-
-module Facter
-  module EC2
-    CONNECTION_ERRORS = [
-      Errno::EHOSTDOWN,
-      Errno::EHOSTUNREACH,
-      Errno::ENETUNREACH,
-      Errno::ECONNABORTED,
-      Errno::ECONNREFUSED,
-      Errno::ECONNRESET,
-      Errno::ETIMEDOUT,
-    ]
-
-    # Contains metadata keys that should not be collected
-    FILTERED_KEYS = [
-      'security-credentials/'
-    ].freeze
-
-    class Base
-      def reachable?(retry_limit = 3)
-        timeout = 0.5
-        able_to_connect = false
-        attempts = 0
-
-        begin
-          open(@baseurl, :proxy => nil, :read_timeout => timeout).read
-          able_to_connect = true
-        rescue OpenURI::HTTPError => e
-          if e.message.match /404 Not Found/i
-            able_to_connect = false
-          else
-            attempts = attempts + 1
-            retry if attempts < retry_limit
-          end
-        rescue Timeout::Error
-          attempts = attempts + 1
-          retry if attempts < retry_limit
-        rescue *CONNECTION_ERRORS
-          attempts = attempts + 1
-          retry if attempts < retry_limit
-        end
-
-        able_to_connect
-      end
-    end
-
-    class Metadata < Base
-
-      DEFAULT_URI = "http://169.254.169.254/latest/meta-data/"
-
-      def initialize(uri = DEFAULT_URI)
-        @baseurl = uri
-      end
-
-      def fetch(path = '')
-        results = {}
-
-        keys = fetch_endpoint(path)
-        keys.each do |key|
-          next if FILTERED_KEYS.include? key
-          if key.match(%r[/$])
-            # If a metadata key is suffixed with '/' then it's a general metadata
-            # resource, so we have to recursively look up all the keys in the given
-            # collection.
-            name = key[0..-2]
-            results[name] = fetch("#{path}#{key}")
-          else
-            # This is a simple key/value pair, we can just query the given endpoint
-            # and store the results.
-            ret = fetch_endpoint("#{path}#{key}")
-            results[key] = ret.size > 1 ? ret : ret.first
-          end
-        end
-
-        results
-      end
-
-      # @param path [String] The path relative to the object base url
-      #
-      # @return [Array, NilClass]
-      def fetch_endpoint(path)
-        uri = @baseurl + path
-        body = open(uri, :proxy => nil).read
-        parse_results(body)
-      rescue OpenURI::HTTPError => e
-        if e.message.match /404 Not Found/i
-          return nil
-        else
-          Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
-          return nil
-        end
-      rescue *CONNECTION_ERRORS => e
-        Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
-        return nil
-      rescue Timeout::Error => e
-        Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
-        return nil
-      end
-
-      private
-
-      def parse_results(body)
-        lines = body.split("\n")
-        lines.map do |line|
-          if (match = line.match(/^(\d+)=.*$/))
-            # Metadata arrays are formatted like '<index>=<associated key>/', so
-            # we need to extract the index from that output.
-            "#{match[1]}/"
-          else
-            line
-          end
-        end
-      end
-    end
-
-    class Userdata < Base
-      DEFAULT_URI = "http://169.254.169.254/latest/user-data/"
-
-      def initialize(uri = DEFAULT_URI)
-        @baseurl = uri
-      end
-
-      def fetch
-        open(@baseurl, :proxy => nil).read
-      rescue OpenURI::HTTPError => e
-        if e.message.match /404 Not Found/i
-          return nil
-        else
-          Facter.log_exception(e, "Failed to fetch ec2 uri #{uri}: #{e.message}")
-          return nil
-        end
-      end
-    end
-  end
-end