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

data/lib/facter/util/posix.rb

@@ -1,16 +0,0 @@
-module Facter
-module Util
-module POSIX
-  # Provides a consistent way of invoking sysctl(8) across POSIX platforms
-  #
-  # @param mib [String] the sysctl(8) MIB name
-  #
-  # @api private
-  def sysctl(mib)
-    Facter::Util::Resolution.exec("sysctl -n #{mib} 2>/dev/null")
-  end
-
-  module_function :sysctl
-end
-end
-end

data/lib/facter/util/processor.rb

@@ -1,289 +0,0 @@
-module Facter
-module Util
-module Processor
-  ##
-  # aix_processor_list is intended to generate a list of values for the
-  # processorX facts.  The behavior is as follows from
-  # [#11609](http://projects.puppetlabs.com/issues/11609)
-  #
-  # 1. Take a list of all the processor identifiers for the platform,
-  #    represented as system-native identifiers in strings.
-  # 2. Sort the list
-  # 3. Assign an incrementing from 0 integer index to each identifier.
-  # 4. Store the value of the system identifier in the processorX fact where X
-  #    is the incrementing index.
-  #
-  # Returns an Array, sorted, containing the values for the facts.
-  def self.aix_processor_list
-    return_value = []
-    aix_proc_id_list = []
-
-    if output = lsdev then
-      output.split("\n").each do |line|
-        if match = line.match(/proc\d+/)
-          aix_proc_id_list << match[0]
-        end
-      end
-    end
-
-    # Generalized alphanumeric sort to put "proc12" behind "proc4"
-    padding = 8
-    aix_proc_id_list = aix_proc_id_list.sort do |a,b|
-      a,b = [a,b].map do |s|
-        s.gsub(/\d+/) { |m| "0"*(padding - m.size) + m }
-      end
-      a<=>b
-    end
-
-    aix_proc_id_list.each do |proc_id|
-      if output = lsattr("lsattr -El #{proc_id} -a type")
-        if match = output.match(/type\s+([^\s]+)\s+Processor/i)
-          return_value << match[1]
-        end
-      end
-    end
-
-    return_value
-  end
-
-  ##
-  # lsdev is intended to directly delegate to Facter::Core::Execution.exec in an
-  # effort to make the processorX facts easier to test by stubbing only the
-  # behaviors we need to stub to get the output of the system command.
-  def self.lsdev(command="lsdev -Cc processor")
-    Facter::Core::Execution.exec(command)
-  end
-
-  ##
-  # lsattr is intended to directly delegate to Facter::Core::Execution.exec in
-  # an effort to make the processorX facts easier to test.  See also the
-  # {lsdev} method.
-  def self.lsattr(command="lsattr -El proc0 -a type")
-    Facter::Core::Execution.exec(command)
-  end
-
-  ##
-  # kernel_fact_value is intended to directly delegate to Facter.value(:kernel)
-  # to make it easier to stub the kernel fact without affecting the entire
-  # system.
-  def self.kernel_fact_value
-    Facter.value(:kernel)
-  end
-
-  ##
-  # hpux_processor_list is intended to generate a list of values for the
-  # processorX facts.
-  def self.hpux_processor_list
-    return_value = []
-    hpux_proc_id_list = []
-    cpu = ""
-
-    ##
-    # first, try parsing machinfo output.
-    if output = machinfo then
-      output.split("\n").each do |line|
-        if line.match(/processor model:\s+\d+\s+(.*)/) then
-          cpu = $1.to_s
-        elsif line.match(/\d+\s+((?:PA-RISC|Intel).*processors.*)/) then
-          cpu = $1.to_s
-          cpu.sub!(/processors/, "processor")
-        elsif line.match(/\s+(Intel.*Processor.*)/) then
-          cpu = $1.to_s
-        end
-      end
-    end
-
-    ##
-    # if that fails, try looking using model command and cross referencing against
-    # sched.models, which could be in three places. This file only catered for
-    # PA-RISC. Unfortunately, the file is not up to date sometimes.
-    if cpu.empty? then
-      m = model
-      m.sub!(/\s+$/, "")
-      m.sub!(/.*\//, "")
-      m.sub!(/.*\s+/, "")
-
-      if sched_models_lines = read_sched_models
-        sched_models_lines.each do |l|
-          if l.match(m) and l.match(/^\S+\s+\d+\.\d+\s+(\S+)/) then
-            cpu = "PA-RISC " + $1.to_s.sub!(/^PA/, "") + " processor"
-            break # we assume first match is the only match.
-          end
-        end
-      end
-    end
-
-    ##
-    # if that also fails, report the CPU version based on unistd.h and chip type based on getconf.
-    if cpu.empty? then
-      cpu_version = getconf_cpu_version
-      cpu_chip_type = getconf_cpu_chip_type
-      cpu_string = ""
-
-      if lines = read_unistd_h("/usr/include/sys/unistd.h") then
-        lines.each do |l|
-          if l.match(/define.*0x#{cpu_version.to_i.to_s(16)}.*\/\*\s+(.*)\s+\*\//) then
-            cpu_string = $1.to_s
-            break
-          end
-        end
-      end
-
-      if cpu_string.empty? then
-        cpu_string = "CPU v" + cpu_version
-      end
-
-      cpu = cpu_string + " CHIP TYPE #" + cpu_chip_type
-    end
-
-    ##
-    # now count (logical) CPUs using ioscan. We set processorX for X in 0..processorcount
-    # to cpu as worked out above. HP-UX does not support more than one installed CPU
-    # model.
-    if output = ioscan then
-      output.split("\n").each do |line|
-        if line.match(/processor/) then
-          hpux_proc_id_list << cpu
-        end
-      end
-    end
-
-    hpux_proc_id_list
-  end
-
-  ##
-  # read_sched_models is intended to be stubbed instead of File.readlines
-  # @return [Array] of strings containing the lines of the file or nil if the
-  # sched.models file could not be located.
-  def self.read_sched_models
-    path = if File.exists?("/usr/lib/sched.models")
-             "/usr/lib/sched.models"
-           elsif File.exists?("/usr/sam/lib/mo/sched.models")
-             "/usr/sam/lib/mo/sched.models"
-           elsif File.exists?("/opt/langtools/lib/sched.models")
-             "/opt/langtools/lib/sched.models"
-           end
-
-    if path
-      File.readlines(path)
-    end
-  end
-  private_class_method :read_sched_models
-
-  ##
-  # read_unistd_h is intended to be stubbed instead of File.readlines
-  # @return [Array] of Strings or nil if the file does not exist.
-  def self.read_unistd_h(path)
-    if File.exists?(path) then
-      File.readlines(path)
-    end
-  end
-  private_class_method :read_unistd_h
-
-  ##
-  # machinfo delegates directly to Facter::Core::Execution.exec, as with lsdev
-  # above.
-  def self.machinfo(command="/usr/contrib/bin/machinfo")
-    Facter::Core::Execution.exec(command)
-  end
-
-  ##
-  # model delegates directly to Facter::Core::Execution.exec.
-  def self.model(command="model")
-    Facter::Core::Execution.exec(command)
-  end
-
-  ##
-  # ioscan delegates directly to Facter::Core::Execution.exec.
-  def self.ioscan(command="ioscan -fknCprocessor")
-    Facter::Core::Execution.exec(command)
-  end
-
-  ##
-  # getconf_cpu_version delegates directly to Facter::Core::Execution.exec.
-  def self.getconf_cpu_version(command="getconf CPU_VERSION")
-    Facter::Core::Execution.exec(command)
-  end
-
-  ##
-  # getconf_cpu_chip_type delegates directly to Facter::Core::Execution.exec.
-  def self.getconf_cpu_chip_type(command="getconf CPU_CHIP_TYPE")
-    Facter::Core::Execution.exec(command)
-  end
-
-  def self.enum_cpuinfo
-    processor_num = -1
-    processor_list = []
-    cpuinfo = "/proc/cpuinfo"
-
-    if File.exists?(cpuinfo)
-      model = Facter.value(:architecture)
-      case model
-      when "x86_64", "amd64", "i386", "x86", /parisc/, "hppa", "ia64"
-        File.readlines(cpuinfo).each do |l|
-          if l =~ /processor\s+:\s+(\d+)/
-            processor_num = $1.to_i
-          elsif l =~ /model name\s+:\s+(.*)\s*$/
-            processor_list[processor_num] = $1 unless processor_num == -1
-            processor_num = -1
-          elsif l =~ /processor\s+(\d+):\s+(.*)/
-            processor_num = $1.to_i
-            processor_list[processor_num] = $2 unless processor_num == -1
-          end
-        end
-
-      when "ppc64", "ppc64le"
-        File.readlines(cpuinfo).each do |l|
-          if l =~ /processor\s+:\s+(\d+)/
-            processor_num = $1.to_i
-          elsif l =~ /cpu\s+:\s+(.*)\s*$/
-            processor_list[processor_num] = $1 unless processor_num == -1
-            processor_num = -1
-          end
-        end
-
-      when /arm/
-        File.readlines(cpuinfo).each do |l|
-          if l =~ /Processor\s+:\s+(.+)/
-            processor_num += 1
-            processor_list[processor_num] = $1.chomp
-          elsif l =~ /processor\s+:\s+(\d+)\s*$/
-            proc_num = $1.to_i
-            if proc_num != 0
-              processor_num += 1
-              processor_list[processor_num] = processor_list[processor_num-1]
-            end
-          end
-        end
-
-      when /sparc/
-        File.readlines(cpuinfo).each do |l|
-          if l =~ /cpu\s+:\s+(.*)\s*$/
-            processor_num += 1
-            processor_list[processor_num] = $1
-          end
-        end
-      end
-    end
-    processor_list
-  end
-
-  def self.enum_kstat
-    processor_num = -1
-    processor_list = []
-    kstat = Facter::Core::Execution.exec('/usr/bin/kstat cpu_info')
-    if kstat
-      kstat.each_line do |l|
-        if l =~ /cpu_info(\d+)/
-          processor_num = $1.to_i
-        elsif l =~ /brand\s+(.*)\s*$/
-          processor_list[processor_num] = $1 unless processor_num == -1
-          processor_num = -1
-        end
-      end
-    end
-    processor_list
-  end
-end
-end
-end

data/lib/facter/util/registry.rb

@@ -1,11 +0,0 @@
-module Facter::Util::Registry
-  class << self
-    def hklm_read(key, value)
-      require 'win32/registry'
-      reg = Win32::Registry::HKEY_LOCAL_MACHINE.open(key)
-      rval = reg[value]
-      reg.close
-      rval
-    end
-  end
-end

data/lib/facter/util/resolution.rb

@@ -1,160 +0,0 @@
-require 'facter/util/confine'
-require 'facter/util/config'
-require 'facter/util/normalization'
-require 'facter/core/execution'
-require 'facter/core/resolvable'
-require 'facter/core/suitable'
-
-# This represents a fact resolution. A resolution is a concrete
-# implementation of a fact. A single fact can have many resolutions and
-# the correct resolution will be chosen at runtime. Each time
-# {Facter.add} is called, a new resolution is created and added to the
-# set of resolutions for the fact named in the call.  Each resolution
-# has a {#has_weight weight}, which defines its priority over other
-# resolutions, and a set of {#confine _confinements_}, which defines the
-# conditions under which it will be chosen. All confinements must be
-# satisfied for a fact to be considered _suitable_.
-#
-# @api public
-class Facter::Util::Resolution
-  # @api private
-  attr_accessor :code
-  attr_writer :value
-
-  extend Facter::Core::Execution
-
-  class << self
-    # Expose command execution methods that were extracted into
-    # Facter::Core::Execution from Facter::Util::Resolution in Facter 2.0.0 for
-    # compatibility.
-    #
-    # @deprecated
-    public :search_paths, :which, :absolute_path?, :expand_command, :with_env, :exec
-  end
-
-  include Facter::Core::Resolvable
-  include Facter::Core::Suitable
-
-  # @!attribute [rw] name
-  # The name of this resolution. The resolution name should be unique with
-  # respect to the given fact.
-  # @return [String]
-  # @api public
-  attr_accessor :name
-
-  # @!attribute [r] fact
-  # @return [Facter::Util::Fact]
-  # @api private
-  attr_reader :fact
-
-  # Create a new resolution mechanism.
-  #
-  # @param name [String] The name of the resolution.
-  # @return [void]
-  #
-  # @api private
-  def initialize(name, fact)
-    @name = name
-    @fact = fact
-    @confines = []
-    @value = nil
-    @timeout = 0
-    @weight = nil
-  end
-
-  def resolution_type
-    :simple
-  end
-
-  # Evaluate the given block in the context of this resolution. If a block has
-  # already been evaluated emit a warning to that effect.
-  #
-  # @return [void]
-  def evaluate(&block)
-    if @last_evaluated
-      msg = "Already evaluated #{@name}"
-      msg << " at #{@last_evaluated}" if msg.is_a? String
-      msg << ", reevaluating anyways"
-      Facter.warn msg
-    end
-
-    instance_eval(&block)
-
-    # Ruby 1.9+ provides the source location of procs which can provide useful
-    # debugging information if a resolution is being evaluated twice. Since 1.8
-    # doesn't support this we opportunistically provide this information.
-    if block.respond_to? :source_location
-      @last_evaluated = block.source_location.join(':')
-    else
-      @last_evaluated = true
-    end
-  end
-
-  def set_options(options)
-    if options[:name]
-      @name = options.delete(:name)
-    end
-
-    if options.has_key?(:value)
-      @value = options.delete(:value)
-    end
-
-    if options.has_key?(:timeout)
-      @timeout = options.delete(:timeout)
-    end
-
-    if options.has_key?(:weight)
-      @weight = options.delete(:weight)
-    end
-
-    if not options.keys.empty?
-      raise ArgumentError, "Invalid resolution options #{options.keys.inspect}"
-    end
-  end
-
-  # Sets the code block or external program that will be evaluated to
-  # get the value of the fact.
-  #
-  # @return [void]
-  #
-  # @overload setcode(string)
-  #   Sets an external program to call to get the value of the resolution
-  #   @param [String] string the external program to run to get the
-  #     value
-  #
-  # @overload setcode(&block)
-  #   Sets the resolution's value by evaluating a block at runtime
-  #   @param [Proc] block The block to determine the resolution's value.
-  #     This block is run when the fact is evaluated. Errors raised from
-  #     inside the block are rescued and printed to stderr.
-  #
-  # @api public
-  def setcode(string = nil, &block)
-    if string
-      @code = Proc.new do
-        output = Facter::Core::Execution.execute(string, :on_fail => nil)
-        if output.nil? or output.empty?
-          nil
-        else
-          output
-        end
-      end
-    elsif block_given?
-      @code = block
-    else
-      raise ArgumentError, "You must pass either code or a block"
-    end
-  end
-
-  private
-
-  def resolve_value
-    if @value
-      @value
-    elsif @code.nil?
-      nil
-    elsif @code
-      @code.call()
-    end
-  end
-end