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

data/lib/facter/util/loader.rb

@@ -1,155 +0,0 @@
-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

@@ -1,43 +0,0 @@
-# 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

@@ -1,73 +0,0 @@
-## 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/lib/facter/util/manufacturer.rb

@@ -1,99 +0,0 @@
-# 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/lib/facter/util/memory.rb

@@ -1,228 +0,0 @@
-## 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