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

data/lib/facter/util/solaris_zones.rb

@@ -1,158 +0,0 @@
-require 'facter/util/resolution'
-
-module Facter
-module Util
-  ##
-  # Provide a set of utility methods to interact with Solaris zones.  This class
-  # is expected to be instantiated once per set of resolutions in order to
-  # cache the output of the zoneadm command, which can be quite expensive.
-  #
-  # @api private
-  class SolarisZones
-    attr_reader :zone_hash
-    attr_reader :zoneadm_cmd
-    attr_reader :zoneadm_output
-    attr_reader :zoneadm_keys
-
-    ##
-    # add_facts defines all of the facts for solaris zones, for example `zones`,
-    # `zone_global_id`, `zone_global_status`, etc...  This method defines the
-    # static fact named `zones`.  The value of this fact is the numver of zones
-    # reported by the zoneadm system command.  The `zones` fact also defines
-    # all of the dynamic facts describing the following seven attribute values
-    # for each zone.
-    #
-    # Zones may be added to the system while Facter is loaded.  In order to
-    # define new dynamic facts that reflect this new information, the `virtual`
-    # will define new facts as a side effect of refreshing it's own value.
-    #
-    # @api private
-    def self.add_facts
-      model = new
-      model.refresh
-      model.add_dynamic_facts
-      Facter.add("zones") do
-        setcode do
-          model.refresh if model.flushed?
-          model.add_dynamic_facts
-          model.count
-        end
-        on_flush do
-          model.flush!
-        end
-      end
-    end
-
-    ##
-    # @param [Hash] opts the options to create the instance with
-    # @option opts [String] :zoneadm_cmd ('/usr/sbin/zoneadm list -cp') the
-    #   system command to inspect zones
-    # @option opts [String] :zoneadm_output (nil) the cached output of the
-    #   zoneadm_cmd
-    def initialize(opts = {})
-      @zoneadm_keys = [:id, :name, :status, :path, :uuid, :brand, :iptype]
-      @zoneadm_cmd = opts[:zoneadm_cmd] || '/usr/sbin/zoneadm list -cp'
-      if opts[:zoneadm_output]
-        @zoneadm_output = opts[:zoneadm_output]
-      end
-    end
-
-    ##
-    # add_dynamic_facts defines all of the dynamic facts derived from parsing
-    # the output of the zoneadm command.  The zone facts are dynamic, so this
-    # method has the behavior of figuring out what dynamic zone facts need to
-    # be defined and how they should be resolved.
-    #
-    # @param model [SolarisZones] the model used to store data from the system
-    #
-    # @api private
-    def add_dynamic_facts
-      model = self
-      zone_hash.each_pair do |zone, attr_hsh|
-        attr_hsh.keys.each do |attr|
-          Facter.add("zone_#{zone}_#{attr}") do
-            setcode do
-              model.refresh if model.flushed?
-              # Don't resolve if the zone has since been deleted
-              if zone_hsh = model.zone_hash[zone]
-                zone_hsh[attr] # the value
-              end
-            end
-            on_flush do
-              model.flush!
-            end
-          end
-        end
-      end
-    end
-
-    ##
-    # refresh executes the zoneadm_cmd and stores the output data.
-    #
-    # @api private
-    #
-    # @return [Hash] the parsed output of the zoneadm command
-    def refresh
-      @zoneadm_output = Facter::Core::Execution.execute(zoneadm_cmd, {:on_fail => nil})
-      parse!
-    end
-
-    ##
-    # parse! parses the string stored in {@zoneadm_output} and stores the
-    # resulting Hash data structure in {@zone_hash}
-    #
-    # @api private
-    def parse!
-      if @zoneadm_output
-        rows = @zoneadm_output.split("\n").collect { |line| line.split(':') }
-      else
-        Facter.debug "Cannot parse zone facts, #{zoneadm_cmd} returned no output"
-        rows = []
-      end
-
-      @zone_hash = rows.inject({}) do |memo, fields|
-        zone = fields[1].intern
-        # Transform the row into a hash with keys named by the column names
-        memo[zone] = Hash[*@zoneadm_keys.zip(fields).flatten]
-        memo
-      end
-    end
-    private :parse!
-
-    ##
-    # count returns the number of running zones, including the global zone.
-    # This method is intended to be used from the setcode block of the `zones`
-    # fact.
-    #
-    # @api private
-    #
-    # @return [Fixnum, nil] the number of running zones or nil if the number
-    #   could not be determined.
-    def count
-      if @zone_hash
-        @zone_hash.size
-      end
-    end
-
-    ##
-    # flush! purges the saved data from the zoneadm_cmd output
-    #
-    # @api private
-    def flush!
-      @zoneadm_output = nil
-      @zone_hash = nil
-    end
-
-    ##
-    # flushed? returns true if the instance has no parsed data accessible via
-    # the {zone_hash} method.
-    #
-    # @api private
-    #
-    # @return [Boolean] true if there is no parsed data, false otherwise
-    def flushed?
-      !@zone_hash
-    end
-  end
-end
-end

data/lib/facter/util/unix_root.rb

@@ -1,5 +0,0 @@
-module Facter::Util::Root
-  def self.root?
-    Process.uid == 0
-  end
-end

data/lib/facter/util/uptime.rb

@@ -1,83 +0,0 @@
-require 'time'
-
-# A module to gather uptime facts
-#
-module Facter::Util::Uptime
-  def self.get_uptime_seconds_unix
-    uptime_proc_uptime or uptime_sysctl or uptime_executable
-  end
-
-  def self.get_uptime_seconds_win
-    require 'facter/util/wmi'
-
-    last_boot = ""
-    Facter::Util::WMI.execquery("select * from Win32_OperatingSystem").each do |x|
-      last_boot = x.LastBootupTime
-    end
-    self.compute_uptime(Time.parse(last_boot.split('.').first))
-  end
-
-  private
-
-  def self.uptime_proc_uptime
-    output = Facter::Core::Execution.execute("/bin/cat #{uptime_file} 2>/dev/null")
-
-    if not output.empty?
-      output.chomp.split(" ").first.to_i
-    end
-  end
-
-  def self.uptime_sysctl
-    require 'facter/util/posix'
-    output = Facter::Util::POSIX.sysctl(uptime_sysctl_variable)
-    if output
-      compute_uptime(Time.at(output.match(/\d+/)[0].to_i))
-    end
-  end
-
-  def self.uptime_executable
-    output = Facter::Core::Execution.execute("#{uptime_executable_cmd} 2>/dev/null", :on_fail => nil)
-
-    if output
-      up=0
-      if output =~ /(\d+) day(?:s|\(s\))?,?\s+(\d+):-?(\d+)/
-        # Regexp handles Solaris, AIX, HP-UX, and Tru64.
-        # 'day(?:s|\(s\))?' says maybe 'day', 'days',
-        #   or 'day(s)', and don't set $2.
-        up=86400*$1.to_i + 3600*$2.to_i + 60*$3.to_i
-      elsif output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) hr(?:s|\(s\))?,/
-        up=86400*$1.to_i + 3600*$2.to_i
-      elsif output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) min(?:s|\(s\))?,/
-        up=86400*$1.to_i + 60*$2.to_i
-      elsif output =~ /(\d+) day(?:s|\(s\))?,/
-        up=86400*$1.to_i
-      elsif output =~ /up\s+(\d+):-?(\d+),/
-        # must anchor to 'up' to avoid matching time of day
-        # at beginning of line. Certain versions of uptime on
-        # Solaris may insert a '-' into the minutes field.
-        up=3600*$1.to_i + 60*$2.to_i
-      elsif output =~ /(\d+) hr(?:s|\(s\))?,/
-        up=3600*$1.to_i
-      elsif output =~ /(\d+) min(?:s|\(s\))?,/
-        up=60*$1.to_i
-      end
-      up
-    end
-  end
-
-  def self.compute_uptime(time)
-    (Time.now - time).to_i
-  end
-
-  def self.uptime_file
-    "/proc/uptime"
-  end
-
-  def self.uptime_sysctl_variable
-    'kern.boottime'
-  end
-
-  def self.uptime_executable_cmd
-    "uptime"
-  end
-end

data/lib/facter/util/values.rb

@@ -1,109 +0,0 @@
-
-module Facter
-  module Util
-    # A util module for facter containing helper methods
-    module Values
-      module_function
-
-      class DeepFreezeError < StandardError; end
-
-      # Duplicate and deeply freeze a given data structure
-      #
-      # @param value [Object] The structure to freeze
-      # @return [void]
-      def deep_freeze(value)
-        case value
-        when Numeric, Symbol, TrueClass, FalseClass, NilClass
-          # These are immutable values, we can safely ignore them
-          value
-        when String
-          value.dup.freeze
-        when Array
-          value.map do |entry|
-            deep_freeze(entry)
-          end.freeze
-        when Hash
-          value.inject({}) do |hash, (key, value)|
-            hash[deep_freeze(key)] = deep_freeze(value)
-            hash
-          end.freeze
-        else
-          raise DeepFreezeError, "Cannot deep freeze #{value}:#{value.class}"
-        end
-      end
-
-      class DeepMergeError < StandardError; end
-
-      # Perform a deep merge of two nested data structures.
-      #
-      # @param left [Object]
-      # @param right [Object]
-      # @param path [Array<String>] The traversal path followed when merging nested hashes
-      #
-      # @return [Object] The merged data structure.
-      def deep_merge(left, right, path = [], &block)
-        ret = nil
-
-        if left.is_a? Hash and right.is_a? Hash
-          ret = left.merge(right) do |key, left_val, right_val|
-            path.push(key)
-            merged = deep_merge(left_val, right_val, path)
-            path.pop
-            merged
-          end
-        elsif left.is_a? Array and right.is_a? Array
-          ret = left.dup.concat(right)
-        elsif right.nil?
-          ret = left
-        elsif left.nil?
-          ret = right
-        elsif left.nil? and right.nil?
-          ret = nil
-        else
-          msg = "Cannot merge #{left.inspect}:#{left.class} and #{right.inspect}:#{right.class}"
-          if not path.empty?
-            msg << " at root"
-            msg << path.map { |part| "[#{part.inspect}]" }.join
-          end
-          raise DeepMergeError, msg
-        end
-
-        ret
-      end
-
-      def convert(value)
-        value = value.to_s if value.is_a?(Symbol)
-        value = value.downcase if value.is_a?(String)
-        value
-      end
-
-      # Flatten the given data structure to something that's suitable to return
-      # as flat facts.
-      #
-      # @param path [String] The fact path to be prefixed to the given value.
-      # @param structure [Object] The data structure to flatten. Nested hashes
-      #   will be recursively flattened, everything else will be returned as-is.
-      #
-      # @return [Hash] The given data structure prefixed with the given path
-      def flatten_structure(path, structure)
-        results = {}
-
-        if structure.is_a? Hash
-          structure.each_pair do |name, value|
-            new_path = "#{path}_#{name}".gsub(/\-|\//, '_')
-            results.merge! flatten_structure(new_path, value)
-          end
-        elsif structure.is_a? Array
-          structure.each_with_index do |value, index|
-            new_path = "#{path}_#{index}"
-            results.merge! flatten_structure(new_path, value)
-          end
-        else
-          results[path] = structure
-        end
-
-        results
-      end
-    end
-  end
-end

data/lib/facter/util/virtual.rb

@@ -1,220 +0,0 @@
-require 'facter/util/posix'
-require 'facter/util/file_read'
-require 'pathname'
-
-module Facter::Util::Virtual
-  ##
-  # virt_what is a delegating helper method intended to make it easier to stub
-  # the system call without affecting other calls to
-  # Facter::Core::Execution.exec
-  #
-  # Per https://bugzilla.redhat.com/show_bug.cgi?id=719611 when run as a
-  # non-root user the virt-what command may emit an error message on stdout,
-  # and later versions of virt-what may emit this message on stderr. This
-  # method ensures stderr is redirected and that error messages are stripped
-  # from stdout.
-  def self.virt_what(cmd = "virt-what")
-    if bindir = Facter::Util::Config.override_binary_dir
-      command = Facter::Core::Execution.which(File.join(bindir, cmd))
-    else
-      command = nil
-    end
-
-    if !command
-      command = Facter::Core::Execution.which(cmd)
-      return unless command
-    end
-
-    if Facter.value(:kernel) == 'windows'
-      redirected_cmd = "#{command} 2>NUL"
-    else
-      redirected_cmd = "#{command} 2>/dev/null"
-    end
-    output = Facter::Core::Execution.exec redirected_cmd
-    output.gsub(/^virt-what: .*$/, '') if output
-  end
-
-  ##
-  # lspci is a delegating helper method intended to make it easier to stub the
-  # system call without affecting other calls to Facter::Core::Execution.exec
-  def self.lspci(command = nil)
-    if command.nil?
-      if ["FreeBSD", "OpenBSD"].include? Facter.value(:kernel)
-        command = "pciconf -lv 2>/dev/null"
-      else
-        command = "lspci 2>/dev/null"
-      end
-    end
-
-    Facter::Core::Execution.exec command
-  end
-
-  def self.openvz?
-    FileTest.directory?("/proc/vz") and not self.openvz_cloudlinux?
-  end
-
-  # So one can either have #6728 work on OpenVZ or Cloudlinux. Whoo.
-  def self.openvz_type
-    return false unless self.openvz?
-    return false unless FileTest.exists?( '/proc/self/status' )
-
-    envid = Facter::Core::Execution.exec( 'grep "envID" /proc/self/status' )
-    if envid =~ /^envID:\s+0$/i
-    return 'openvzhn'
-    elsif envid =~ /^envID:\s+(\d+)$/i
-    return 'openvzve'
-    end
-  end
-
-  # Cloudlinux uses OpenVZ to a degree, but always has an empty /proc/vz/ and
-  # has /proc/lve/list present
-  def self.openvz_cloudlinux?
-    FileTest.file?("/proc/lve/list") or Dir.glob('/proc/vz/*').empty?
-  end
-
-  def self.zone?
-    return true if FileTest.directory?("/.SUNWnative")
-    z = Facter::Core::Execution.exec("/sbin/zonename")
-    return false unless z
-    return z.chomp != 'global'
-  end
-
-  def self.vserver?
-    return false unless FileTest.exists?("/proc/self/status")
-    txt = File.open("/proc/self/status", "rb").read
-    if txt.respond_to?(:encode!)
-      txt.encode!('UTF-16', 'UTF-8', :invalid => :replace)
-      txt.encode!('UTF-8', 'UTF-16')
-    end
-    return true if txt =~ /^(s_context|VxID):[[:blank:]]*[0-9]/
-    return false
-  end
-
-  def self.vserver_type
-    if self.vserver?
-      if FileTest.exists?("/proc/virtual")
-        "vserver_host"
-      else
-        "vserver"
-      end
-    end
-  end
-
-  def self.xen?
-    ["/proc/sys/xen", "/sys/bus/xen", "/proc/xen" ].detect do |f|
-      FileTest.exists?(f)
-    end
-  end
-
-  def self.ec2?
-    File.read("/sys/devices/virtual/dmi/id/bios_vendor") =~ /Amazon EC2/ rescue false
-  end
-
-  def self.kvm?
-     txt = if FileTest.exists?("/proc/cpuinfo")
-       File.read("/proc/cpuinfo")
-     elsif ["FreeBSD", "OpenBSD"].include? Facter.value(:kernel)
-       Facter::Util::POSIX.sysctl("hw.model")
-     elsif Facter.value(:kernel) == "SunOS" and FileTest.exists?("/usr/sbin/prtconf")
-       Facter::Core::Execution.exec("/usr/sbin/prtconf -v")
-     end
-     (txt =~ /QEMU Virtual (CPU|Machine)/i) ? true : false
-  end
-
-  def self.virtualbox?
-    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /VirtualBox/ rescue false
-  end
-
-  def self.kvm_type
-    # TODO Tell the difference between kvm and qemu
-    # Can't work out a way to do this at the moment that doesn't
-    # require a special binary
-    if self.kvm?
-      "kvm"
-    end
-  end
-
-  def self.rhev?
-    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /RHEV Hypervisor/ rescue false
-  end
-
-  def self.ovirt?
-    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /oVirt Node/ rescue false
-  end
-
-  def self.gce?
-    File.read("/sys/devices/virtual/dmi/id/product_name") =~ /Google/ rescue false
-  end
-
-  def self.nitro?
-    File.read("/sys/devices/virtual/dmi/id/bios_vendor") =~ /Amazon/ rescue false
-  end
-
-  def self.jail?
-    path = case Facter.value(:kernel)
-      when "FreeBSD" then "/sbin"
-      when "GNU/kFreeBSD" then "/bin"
-    end
-    Facter::Core::Execution.exec("#{path}/sysctl -n security.jail.jailed") == "1"
-  end
-
-  def self.hpvm?
-    Facter::Core::Execution.exec("/usr/bin/getconf MACHINE_MODEL").chomp =~ /Virtual Machine/
-  end
-
-  ##
-  # lxc? returns true if the process is running inside of a linux container.
-  # Implementation derived from
-  # http://stackoverflow.com/questions/20010199/determining-if-a-process-runs-inside-lxc-docker
-  def self.lxc?
-    path = Pathname.new('/proc/1/cgroup')
-    return false unless path.readable?
-    begin
-      in_lxc = path.readlines.any? {|l| l.split(":")[2].to_s.include? '/lxc' }
-    rescue Errno::EPERM => exc
-      # If we get "operation not permitted" here, it probably means we are
-      # running OpenVZ. We are not running LXC anyway, so...
-      return false
-    end
-    return true if in_lxc
-    return false
-  end
-
-  ##
-  # docker? returns true if the process is running inside of a docker container.
-  # Implementation derived from observation of a boot2docker system
-  def self.docker?
-    path = Pathname.new('/proc/1/cgroup')
-    return false unless path.readable?
-    begin
-      in_docker = path.readlines.any? {|l| l.split(":")[2].to_s.include? '/docker' }
-    rescue Errno::EPERM => exc
-      # This can fail under OpenVZ, just like in .lxc?
-      return false
-    end
-    return true if in_docker
-    return false
-  end
-
-  def self.zlinux?
-    "zlinux"
-  end
-
-  ##
-  # read_sysfs Reads the raw data as per the documentation at [Detecting if You
-  # Are Running in Google Compute
-  # Engine](https://developers.google.com/compute/docs/instances#dmi)  This
-  # method is intended to provide an easy seam to mock.
-  #
-  # @api public
-  #
-  # @return [String] or nil if the path does not exist or is unreadable
-  def self.read_sysfs_dmi_entries(path="/sys/firmware/dmi/entries/1-0/raw")
-    if File.readable?(path)
-      begin
-        Facter::Util::FileRead.read_binary(path)
-      rescue Errno::EINVAL
-      end
-    end
-  end
-end