facter 4.0.24 → 4.0.30

data/lib/facter/facts/linux/hypervisors/hyper_v.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class HyperV
+        FACT_NAME = 'hypervisors.hyperv'
+
+        def call_the_resolver
+          fact_value = check_hyper_v
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        def check_hyper_v
+          manufacturer = Facter::Resolvers::Linux::DmiBios.resolve(:sys_vendor)
+          product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+
+          return {} if manufacturer =~ /Microsoft/ || product_name == 'Virtual Machine'
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/hypervisors/kvm.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class Kvm
+        FACT_NAME = 'hypervisors.kvm'
+
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def call_the_resolver
+          hypervisor = discover_hypervisor
+          @log.debug("Detected hypervisor #{hypervisor}")
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) if %w[virtualbox parallels].include?(hypervisor)
+
+          fact_value = discover_provider if kvm?
+
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        private
+
+        def discover_hypervisor
+          product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+          @log.debug("Detected product name: #{product_name}")
+
+          return unless product_name
+
+          Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+          product_name
+        end
+
+        def kvm?
+          bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+          @log.debug("Detected bios vendor: #{bios_vendor}")
+
+          Facter::Resolvers::VirtWhat.resolve(:vm) == 'kvm' ||
+            Facter::Resolvers::Lspci.resolve(:vm) == 'kvm' ||
+            bios_vendor&.include?('Amazon EC2') ||
+            bios_vendor&.include?('Google')
+        end
+
+        def discover_provider
+          manufacturer = Facter::Resolvers::Linux::DmiBios.resolve(:sys_vendor)
+          @log.debug("Detected manufacturer: #{manufacturer}")
+
+          return { google: true } if manufacturer == 'Google'
+
+          return { openstack: true } if manufacturer =~ /^OpenStack/
+
+          return { amazon: true } if manufacturer =~ /^Amazon/
+
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/hypervisors/lxc.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class Lxc
+        FACT_NAME = 'hypervisors.lxc'
+
+        def call_the_resolver
+          fact_value = check_lxc
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        def check_lxc
+          info = Facter::Resolvers::Containers.resolve(:hypervisor)
+          info[:lxc] if info
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/hypervisors/openvz.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class Openvz
+        FACT_NAME = 'hypervisors.openvz'
+
+        def call_the_resolver
+          fact_value = check_openvz
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        def check_openvz
+          openvz = Facter::Resolvers::OpenVz.resolve(:vm)
+          return unless openvz
+
+          id = Facter::Resolvers::OpenVz.resolve(:id)
+
+          { id: id.to_i, host: openvz == 'openvzhn' }
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/hypervisors/systemd_nspawn.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class SystemdNspawn
+        FACT_NAME = 'hypervisors.systemd_nspawn'
+
+        def call_the_resolver
+          fact_value = check_nspawn
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        def check_nspawn
+          info = Facter::Resolvers::Containers.resolve(:hypervisor)
+          info[:systemd_nspawn] if info
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/hypervisors/virtualbox.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class VirtualBox
+        FACT_NAME = 'hypervisors.virtualbox'
+
+        def call_the_resolver
+          fact_value = check_virtualbox
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        def check_virtualbox
+          virtualbox_details = nil
+
+          if Facter::Resolvers::Linux::DmiBios.resolve(:product_name) == 'VirtualBox' ||
+             Facter::Resolvers::VirtWhat.resolve(:vm) =~ /virtualbox/ ||
+             Facter::Resolvers::Lspci.resolve(:vm) == 'virtualbox'
+
+            virtualbox_details = {}
+
+            version = Facter::Resolvers::DmiDecode.resolve(:virtualbox_version)
+            revision = Facter::Resolvers::DmiDecode.resolve(:virtualbox_revision)
+
+            virtualbox_details[:version] = version if version
+            virtualbox_details[:revision] = revision if revision
+          end
+
+          virtualbox_details
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/hypervisors/vmware.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class Vmware
+        FACT_NAME = 'hypervisors.vmware'
+
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def call_the_resolver
+          if vmware?
+            @log.debug('Vmware hypervisor detected')
+            fact_value = {}
+
+            fact_value[:version] = Facter::Resolvers::DmiDecode.resolve(:vmware_version) || ''
+
+            return Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+
+          @log.debug('No Vmware hypervisor detected.')
+          []
+        end
+
+        private
+
+        def vmware?
+          Facter::Resolvers::VirtWhat.resolve(:vm) == 'vmware' ||
+            Facter::Resolvers::Linux::DmiBios.resolve(:product_name) == 'VMware' ||
+            Facter::Resolvers::Lspci.resolve(:vm) == 'vmware' ||
+            Facter::Resolvers::Linux::DmiBios.resolve(:sys_vendor) == 'VMware, Inc.'
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/hypervisors/xen.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Hypervisors
+      class Xen
+        FACT_NAME = 'hypervisors.xen'
+
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def call_the_resolver
+          if xen?
+            @log.debug('Xen hypervisor detected')
+            fact_value = {}
+
+            fact_value[:context] = hvm? ? 'hvm' : 'pv'
+            fact_value[:privileged] = Facter::Resolvers::Xen.resolve(:privileged)
+
+            return Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+
+          @log.debug('No Xen hypervisor detected.')
+          []
+        end
+
+        private
+
+        def xen?
+          Facter::Resolvers::VirtWhat.resolve(:vm) =~ /xen/ ||
+            Facter::Resolvers::Xen.resolve(:vm) =~ /xen/ ||
+            discover_hypervisor == 'xenhvm' ||
+            Facter::Resolvers::Lspci.resolve(:vm) =~ /xen/
+        end
+
+        def hvm?
+          discover_hypervisor == 'xenhvm' || Facter::Resolvers::Lspci.resolve(:vm) == 'xenhvm'
+        end
+
+        def discover_hypervisor
+          product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+          return unless product_name
+
+          Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+          product_name
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/is_virtual.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class IsVirtual
+      FACT_NAME = 'is_virtual'
+
+      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::Containers.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
+
+        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+        nil
+      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

data/lib/facter/facts/linux/networking/dhcp.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Networking
+      class Dhcp
+        FACT_NAME = 'networking.dhcp'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::NetworkingLinux.resolve(:dhcp)
+
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+      end
+    end
+  end
+end