Merge branch 'master' into FACT-2600

.github/actions/presuite.rb

@@ -53,7 +53,6 @@ def install_puppet_agent
   presuite_file_path = "#{beaker_puppet_root.chomp}/setup/aio/010_Install_Puppet_Agent.rb"
 
   run("beaker exec pre-suite --pre-suite #{presuite_file_path} --preserve-state", './', env_path_var)
-  # run("facter -v", puppet_bin_dir)
 end
 
 def puppet_bin_dir
@@ -86,7 +85,6 @@ def replace_facter_3_with_facter_4
   message('CHANGE FACTER 3 WITH FACTER 4')
 
   extension = (HOST_PLATFORM.include? 'windows') ? '.bat' : ''
-  run("mv facter#{extension} facter-old#{extension}", puppet_bin_dir)
   run("mv facter-ng#{extension} facter#{extension}", puppet_bin_dir)
   # run("facter -v", puppet_bin_dir)
 end
@@ -106,7 +104,7 @@ def install_latest_facter_4(gem_command)
 def run_acceptance_tests
   message('RUN ACCEPTANCE TESTS')
 
-  run('beaker exec tests --test-tag-exclude=server,facter_3 --test-tag-or=risk:high,audit:high', './', env_path_var)
+  run('beaker exec tests', './', env_path_var)
 end
 
 def message(message)

.github/workflows/acceptance_tests.yml

@@ -14,7 +14,7 @@ jobs:
     name: Platform
     strategy:
       matrix:
-        os: [windows-2019]
+        os: [windows-2016]
     runs-on: ${{ matrix.os }}
     env:
       FACTER_3_ROOT: facter_3

lib/facts/linux/is_virtual.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class IsVirtual
+      FACT_NAME = 'is_virtual'
+      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
+
+      def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        fact_value = check_docker_lxc || check_gce || retrieve_from_virt_what || check_vmware
+        fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
+
+        Facter::ResolvedFact.new(FACT_NAME, check_if_virtual(fact_value))
+      end
+
+      def check_gce
+        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+        'gce' if bios_vendor&.include?('Google')
+      end
+
+      def check_docker_lxc
+        Facter::Resolvers::DockerLxc.resolve(:vm)
+      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_other_facts
+        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+        return 'kvm' if bios_vendor&.include?('Amazon EC2')
+        return unless product_name
+
+        HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+      end
+
+      def check_lspci
+        Facter::Resolvers::Lspci.resolve(:vm)
+      end
+
+      def check_if_virtual(found_vm)
+        PHYSICAL_HYPERVISORS.count(found_vm).zero?
+      end
+    end
+  end
+end

lib/facts/linux/virtual.rb

@@ -4,9 +4,14 @@ module Facts
   module Linux
     class Virtual
       FACT_NAME = 'virtual'
+      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
 
-      def call_the_resolver
+      def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         fact_value = check_docker_lxc || check_gce || retrieve_from_virt_what || check_vmware
+        fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
 
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
@@ -27,6 +32,31 @@ def check_vmware
       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_other_facts
+        product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+        bios_vendor =  Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+        return 'kvm' if bios_vendor&.include?('Amazon EC2')
+        return unless product_name
+
+        HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+      end
+
+      def check_lspci
+        Facter::Resolvers::Lspci.resolve(:vm)
+      end
     end
   end
 end

lib/resolvers/lspci.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Lspci < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      REGEX_VALUES = { 'VirtualBox' => 'virtualbox', 'XenSource' => 'xenhvm',
+                       'Microsoft Corporation Hyper-V' => 'hyperv', 'Class 8007: Google, Inc' => 'gce',
+                       'VM[wW]are' => 'vmware', '1ab8:' => 'parallels', '[Pp]arallels' => 'parallels',
+                       '(?i)(virtio)' => 'kvm' }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { lspci_command(fact_name) }
+        end
+
+        def lspci_command(fact_name)
+          output = Facter::Core::Execution.execute('lspci', logger: log)
+          return if output.empty?
+
+          @fact_list[:vm] = retrieve_vm(output)
+          @fact_list[fact_name]
+        end
+
+        def retrieve_vm(output)
+          output.each_line { |line| REGEX_VALUES.each { |key, value| return value if line =~ /#{key}/ } }
+        end
+      end
+    end
+  end
+end

lib/resolvers/open_vz.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OpenVz < BaseResolver
+      # build
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { check_proc_vz(fact_name) }
+        end
+
+        def check_proc_vz(fact_name)
+          if !Dir.exist?('/proc/vz') || !File.executable?('/proc/lve/list') || Dir.entries('/proc/vz').count.equal?(2)
+            return
+          end
+
+          @fact_list[:vm] = read_proc_status
+          @fact_list[fact_name]
+        end
+
+        def read_proc_status
+          proc_status_content = Facter::Util::FileHelper.safe_readlines('/proc/self/status', nil)
+          return unless proc_status_content
+
+          proc_status_content.each do |line|
+            parts = line.split("\s")
+            next unless parts.size.equal?(2)
+
+            next unless /^envID:/ =~ parts[0]
+
+            return 'openvzhn' if parts[1] == '0'
+
+            return 'openvzve'
+          end
+        end
+      end
+    end
+  end
+end

lib/resolvers/xen.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Xen < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { chech_xen_dirs(fact_name) }
+        end
+
+        def chech_xen_dirs(fact_name)
+          xen_type = 'xen0' if File.exist?('/dev/xen/evtchn')
+          xen_type = 'xenu' if !xen_type && (File.exist?('/proc/xen') || File.exist?('/dev/xvda1'))
+
+          @fact_list[:vm] = xen_type
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end