openfact 5.0.0.rc0

data/lib/facter/resolvers/windows/win_os_description.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class WinOsDescription < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_from_ole(fact_name) }
+        end
+
+        def read_from_ole(fact_name)
+          win = Facter::Util::Windows::Win32Ole.new
+          op_sys = win.return_first('SELECT ProductType,OtherTypeDescription FROM Win32_OperatingSystem')
+          unless op_sys
+            @log.debug 'WMI query returned no results for Win32_OperatingSystem'\
+                       'with values ProductType and OtherTypeDescription.'
+            return
+          end
+          @fact_list[:consumerrel] = (op_sys.ProductType == 1)
+          @fact_list[:description] = op_sys.OtherTypeDescription
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/wpar.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Wpar < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_wpar(fact_name) }
+        end
+
+        def read_wpar(fact_name)
+          output = Facter::Core::Execution.execute('/usr/bin/lparstat -W', logger: log)
+
+          return if output.empty?
+
+          output.each_line do |line|
+            populate_wpar_data(line.split(':').map(&:strip))
+          end
+          @fact_list[fact_name]
+        end
+
+        def populate_wpar_data(key_value)
+          @fact_list[:wpar_key]              = key_value[1].to_i if key_value[0] == 'WPAR Key'
+          @fact_list[:wpar_configured_id]    = key_value[1].to_i if key_value[0] == 'WPAR Configured ID'
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/xen.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Xen < BaseResolver
+      init_resolver
+
+      XEN_PATH = '/proc/xen/capabilities'
+      XEN_TOOLSTACK = '/usr/lib/xen-common/bin/xen-toolstack'
+      XEN_COMMANDS = ['/usr/sbin/xl', '/usr/sbin/xm'].freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { detect_xen(fact_name) }
+        end
+
+        def detect_xen(fact_name)
+          @fact_list[:vm] = detect_xen_type
+          @fact_list[:privileged] = privileged?(@fact_list[:vm])
+          @fact_list[:domains] = detect_domains
+
+          @fact_list[fact_name]
+        end
+
+        def detect_xen_type
+          xen_type = 'xen0' if File.exist?('/dev/xen/evtchn')
+          if !xen_type && (File.exist?('/proc/xen') || (File.exist?('/dev/xvda1') && !File.symlink?('/dev/xvda1')))
+            xen_type = 'xenu'
+          end
+
+          xen_type
+        end
+
+        def privileged?(xen_type)
+          content = Facter::Util::FileHelper.safe_read(XEN_PATH, nil)
+          content&.strip == 'control_d' || xen_type == 'xen0'
+        end
+
+        def detect_domains
+          domains = []
+          xen_command = find_command
+          return unless xen_command
+
+          output = Facter::Core::Execution.execute("#{xen_command} list", logger: log)
+          return if output.empty?
+
+          output.each_line do |line|
+            next if /Domain-0|Name/.match?(line)
+
+            domain = line.match(/^([^\s]*)\s/)
+            domain = domain&.captures&.first
+            domains << domain if domain
+          end
+
+          domains
+        end
+
+        def find_command
+          num_stacks = 0
+          XEN_COMMANDS.each do |command|
+            num_stacks += 1 if File.exist?(command)
+          end
+
+          return XEN_TOOLSTACK if num_stacks > 1 && File.exist?(XEN_TOOLSTACK)
+
+          XEN_COMMANDS.each { |command| return command if File.exist?(command) }
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/zfs.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class ZFS < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { zfs_fact(fact_name) }
+        end
+
+        def zfs_fact(fact_name)
+          build_zfs_facts
+          @fact_list[fact_name]
+        end
+
+        def build_zfs_facts
+          output = Facter::Core::Execution.execute('zfs upgrade -v', logger: log)
+          features_list = output.scan(/^\s+(\d+)/).flatten
+
+          return if features_list.empty?
+
+          @fact_list[:zfs_featurenumbers] = features_list.join(',')
+          @fact_list[:zfs_version] = features_list.last
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/zpool.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Zpool < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { zpool_fact(fact_name) }
+        end
+
+        def zpool_fact(fact_name)
+          build_zpool_facts
+          @fact_list[fact_name]
+        end
+
+        def build_zpool_facts
+          output = Facter::Core::Execution.execute('zpool upgrade -v', logger: log)
+          features_list = output.scan(/^\s+(\d+)/).flatten
+          features_flags = output.scan(/^([a-z0-9_]+)[[:blank:]]*(\(read-only compatible\))?$/).map(&:first)
+
+          return if features_list.empty?
+
+          @fact_list[:zpool_featurenumbers] = features_list.join(',')
+          @fact_list[:zpool_featureflags] = features_flags.join(',')
+          @fact_list[:zpool_version] = features_flags.any? ? '5000' : features_list.last
+        end
+      end
+    end
+  end
+end

data/lib/facter/templates/man.erb

@@ -0,0 +1,133 @@
+<%# encoding: UTF-8%>
+facter - collect and display facts about the current system
+===========================================================
+
+SYNOPSIS
+--------
+<b>facter</b> [options] [query] [query] [...]
+
+DESCRIPTION
+-----------
+<b>facter</b> is a command-line tool that gathers basic facts about nodes (systems) such as hardware details, network settings, OS type and version, and more. These facts are made available as variables in your Puppet manifests and can be used to inform conditional expressions in Puppet.
+
+If no queries are given, then all facts will be returned.
+
+Many of the command line options can also be set via the HOCON config file. This file can also be used to block or cache certain fact groups.
+
+OPTIONS
+-------
+<% Facter::Cli.class_options.each do |name, option| -%><% next if option.hide%>
+  * `<%= option.aliases[0] + '`, `' if option.aliases.any? %>--<%= 'no-' if negate_options.include?(name.to_s)%><%= name.to_s.gsub('_','-') %>`:
+
+    <%= option.description %>
+
+<% end -%>
+
+<% Facter::Cli.commands.select { |_k, command_class| command_class.instance_of?(Thor::Command) }.each do |_, command| -%>
+  * `<%= command.usage %>`:
+
+    <%= command.description %>
+
+
+<% end -%>
+
+FILES
+-----
+<em>/etc/puppetlabs/facter/facter.conf</em>
+
+A HOCON config file that can be used to specify directories for custom and external facts, set various command line options, and specify facts to block. See example below for details, or visit the [GitHub README](https://github.com/puppetlabs/puppetlabs-hocon#overview).
+
+EXAMPLES
+--------
+Display all facts:
+
+```
+$ facter
+disks => {
+  sda => {
+    model => "Virtual disk",
+    size => "8.00 GiB",
+    size_bytes => 8589934592,
+    vendor => "ExampleVendor"
+  }
+}
+dmi => {
+  bios => {
+    release_date => "06/23/2013",
+    vendor => "Example Vendor",
+    version => "6.00"
+  }
+}
+[...]
+```
+
+Display a single structured fact:
+
+```
+$ facter processors
+{
+  count => 2,
+  isa => "x86_64",
+  models => [
+    "Intel(R) Xeon(R) CPU E5-2680 v2 @ 2.80GHz",
+    "Intel(R) Xeon(R) CPU E5-2680 v2 @ 2.80GHz"
+  ],
+  physicalcount => 2
+}
+```
+
+Display a single fact nested within a structured fact:
+
+```
+$ facter processors.isa
+x86_64
+```
+
+Display a single legacy fact. Note that non-structured facts existing in previous versions of Facter are still available,
+but are not displayed by default due to redundancy with newer structured facts:
+
+```
+$ facter processorcount
+2
+```
+
+Format facts as JSON:
+
+```
+$ facter --json os.name os.release.major processors.isa
+{
+  "os.name": "Ubuntu",
+  "os.release.major": "14.04",
+  "processors.isa": "x86_64"
+}
+```
+
+An example config file.
+
+```
+# always loaded (CLI and as Ruby module)
+global : {
+    external-dir : "~/external/facts",
+    custom-dir   :  [
+       "~/custom/facts",
+       "~/custom/facts/more-facts"
+    ],
+    no-external-facts : false,
+    no-custom-facts   : false,
+    no-ruby           : false
+}
+# loaded when running from the command line
+cli : {
+    debug     : false,
+    trace     : true,
+    verbose   : false,
+    log-level : "info"
+}
+# always loaded, fact-specific configuration
+facts : {
+    # for valid blocklist entries, use --list-block-groups
+    blocklist : [ "file system", "EC2" ],
+    # for valid time-to-live entries, use --list-cache-groups
+    ttls : [ { "timezone" : 30 days } ]
+}
+```

data/lib/facter/util/aix/info_extractor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Aix
+      module InfoExtractor
+        MEGABYTES_EXPONENT = 1024**2
+        GIGABYTES_EXPONENT = 1024**3
+        PROPERTIES = {
+          lslv: [
+            'LOGICAL VOLUME:',
+            'VOLUME GROUP:',
+            'LV IDENTIFIER:',
+            'PERMISSION:',
+            'VG STATE:',
+            'LV STATE:',
+            'TYPE:',
+            'WRITE VERIFY:',
+            'MAX LPs:',
+            'PP SIZE:',
+            'COPIES:',
+            'SCHED POLICY:',
+            'LPs:',
+            'PPs:',
+            'STALE PPs:',
+            'BB POLICY:',
+            'INTER-POLICY:',
+            'RELOCATABLE:',
+            'INTRA-POLICY:',
+            'UPPER BOUND:',
+            'MOUNT POINT:',
+            'LABEL:',
+            'MIRROR WRITE CONSISTENCY:',
+            'EACH LP COPY ON A SEPARATE PV ?:',
+            'Serialize IO ?:'
+          ],
+          lspv: [
+            'PHYSICAL VOLUME:',
+            'VOLUME GROUP:',
+            'PV IDENTIFIER:',
+            'VG IDENTIFIER',
+            'PV STATE:',
+            'STALE PARTITIONS:',
+            'ALLOCATABLE:',
+            'PP SIZE:',
+            'LOGICAL VOLUMES:',
+            'TOTAL PPs:',
+            'VG DESCRIPTORS:',
+            'FREE PPs:',
+            'HOT SPARE:',
+            'USED PPs:',
+            'MAX REQUEST:',
+            'FREE DISTRIBUTION:',
+            'USED DISTRIBUTION:',
+            'MIRROR POOL:'
+          ]
+        }.freeze
+
+        def self.extract(content, cmd)
+          property_hash = {}
+          properties = PROPERTIES[cmd]
+          properties.each do |property|
+            str = (properties - [property]).join('|')
+            matcher = content.match(/(?:^|^[^:]+:[^:]+)#{Regexp.escape(property)}([^\n]*?)(#{str}|\n|$)/s)
+            if matcher
+              value = matcher[1].strip
+              property_hash[property.split(':').first] = value
+            end
+          end
+          property_hash
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/aix/odm_query.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# CuAt (Customized Attributes) non-default attribute values
+# CuDv (Customized Devices) the devices present on this machine
+# PdAt (Predefined Attributes) default values for all device attributes
+# PdDv (Predefined Devices) the list of all devices supported by this release of AIX
+
+module Facter
+  module Util
+    module Aix
+      class ODMQuery
+        REPOS = %w[CuAt CuDv PdAt PdDv].freeze
+
+        def initialize
+          @query = ''
+          @conditions = []
+          @log = Facter::Log.new(self)
+        end
+
+        def equals(field, value)
+          @conditions << "#{field}='#{value}'"
+          self
+        end
+
+        def like(field, value)
+          @conditions << "#{field} like '#{value}'"
+          self
+        end
+
+        def execute
+          result = nil
+          REPOS.each do |repo|
+            break if result && !result.empty?
+
+            result = Facter::Core::Execution.execute("#{query} #{repo}", logger: @log)
+          end
+          result
+        end
+
+        def query
+          "odmget -q \"#{@conditions.join(' AND ')}\""
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/api_debugger.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module ApiDebugger
+      def self.prepended(receiver)
+        exclude, print_caller = parse_options(ENV['API_DEBUG'])
+
+        receiver_methods = receiver.instance_methods - Object.methods
+        receiver_methods.each do |meth|
+          ApiDebugger.class_eval do
+            define_method(meth) do |*args|
+              method_call = super(*args)
+
+              unless exclude.include?(meth)
+                puts '#' * 80
+                puts "Method call: #{meth}"
+                puts "Called with: #{args.inspect}"
+                if print_caller.include?(meth)
+                  puts '-' * 80
+                  puts caller
+                end
+                puts '#' * 80
+              end
+              method_call
+            end
+          end
+        end
+      end
+
+      def self.parse_options(options)
+        exclude = []
+        print_caller = []
+
+        options.split(',').each do |option|
+          if option.start_with?('-')
+            exclude << option[1..-1].to_sym
+          elsif option.start_with?('+')
+            print_caller << option[1..-1].to_sym
+          end
+        end
+
+        [exclude, print_caller]
+      end
+    end
+  end
+end

data/lib/facter/util/facts/facts_utils.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      HYPERVISORS_HASH = { 'VMware' => 'vmware', 'VirtualBox' => 'virtualbox', 'Parallels' => 'parallels',
+                           'KVM' => 'kvm', 'Virtual Machine' => 'hyperv', 'RHEV Hypervisor' => 'rhev',
+                           'oVirt Node' => 'ovirt', 'HVM domU' => 'xenhvm', 'Bochs' => 'bochs', 'OpenBSD' => 'vmm',
+                           'BHYVE' => 'bhyve' }.freeze
+
+      PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
+      REDHAT_FAMILY = %w[redhat rhel fedora centos scientific ascendos cloudlinux psbm
+                         oraclelinux ovs oel amazon xenserver xcp-ng virtuozzo photon mariner azurelinux].freeze
+      DEBIAN_FAMILY = %w[debian ubuntu huaweios linuxmint devuan kde].freeze
+      SUSE_FAMILY = %w[sles sled suse].freeze
+      GENTOO_FAMILY = ['gentoo'].freeze
+      ARCH_FAMILY = %w[arch manjaro].freeze
+      MANDRAKE_FAMILY = %w[mandrake mandriva mageia].freeze
+      FAMILY_HASH = { 'RedHat' => REDHAT_FAMILY, 'Debian' => DEBIAN_FAMILY, 'Suse' => SUSE_FAMILY,
+                      'Gentoo' => GENTOO_FAMILY, 'Archlinux' => ARCH_FAMILY, 'Mandrake' => MANDRAKE_FAMILY }.freeze
+
+      class << self
+        def discover_family(os)
+          FAMILY_HASH.each { |key, array_value| return key if array_value.any? { |os_flavour| os =~ /#{os_flavour}/i } }
+          os
+        end
+
+        def release_hash_from_string(output, include_patch: false)
+          return unless output
+
+          versions = output.split('.')
+          {}.tap do |release|
+            release['full'] = output
+            release['major'] = versions[0]
+            release['minor'] = versions[1] if versions[1]
+            release['patch'] = versions[2] if versions[2] && include_patch
+          end
+        end
+
+        def release_hash_from_matchdata(data)
+          return if data.nil? || data[1].nil?
+
+          release_hash_from_string(data[1].to_s)
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/posix/virtual_detector.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      module Posix
+        module VirtualDetector
+          class << self
+            def platform
+              @fact_value ||= # rubocop:disable Naming/MemoizedInstanceVariableName
+                check_docker_lxc || check_freebsd || check_openbsd || check_gce || check_illumos_lx || \
+                retrieve_from_virt_what || check_vmware || check_open_vz || check_vserver || \
+                check_xen || check_other_facts || check_lspci || 'physical'
+            end
+
+            private
+
+            def check_docker_lxc
+              return unless Object.const_defined?('Facter::Resolvers::Linux::Containers')
+
+              Facter::Resolvers::Linux::Containers.resolve(:vm)
+            end
+
+            def check_gce
+              return unless Object.const_defined?('Facter::Resolvers::Linux::DmiBios')
+
+              bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+              'gce' if bios_vendor&.include?('Google')
+            end
+
+            def check_illumos_lx
+              'illumos-lx' if Facter::Resolvers::Uname.resolve(:kernelversion) == 'BrandZ virtual linux'
+            end
+
+            def check_vmware
+              Facter::Resolvers::Vmware.resolve(:vm)
+            end
+
+            def retrieve_from_virt_what
+              Facter::Resolvers::VirtWhat.resolve(:vm)
+            end
+
+            def check_open_vz
+              Facter::Resolvers::OpenVz.resolve(:vm)
+            end
+
+            def check_vserver
+              Facter::Resolvers::VirtWhat.resolve(:vserver)
+            end
+
+            def check_xen
+              Facter::Resolvers::Xen.resolve(:vm)
+            end
+
+            def check_freebsd
+              return unless Object.const_defined?('Facter::Resolvers::Freebsd::Virtual')
+
+              Facter::Resolvers::Freebsd::Virtual.resolve(:vm)
+            end
+
+            def check_openbsd
+              return unless Object.const_defined?('Facter::Resolvers::Openbsd::Virtual')
+
+              Facter::Resolvers::Openbsd::Virtual.resolve(:vm)
+            end
+
+            def check_other_facts
+              return unless Object.const_defined?('Facter::Resolvers::Linux::DmiBios')
+
+              bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+              return 'kvm' if bios_vendor&.include?('Amazon EC2')
+
+              product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+              return unless product_name
+
+              Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+              nil
+            end
+
+            def check_lspci
+              Facter::Resolvers::Lspci.resolve(:vm)
+            end
+          end
+        end
+      end
+    end
+  end
+end