facter 4.0.23

data/lib/resolvers/dmi_resolver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class DmiBios < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          # :bios_vendor
+          # :bios_date
+          # :bios_version
+          # :board_vendor
+          # :board_serial
+          # :board_name
+          # :chassis_asset_tag
+          # :chassis_type
+          # :sys_vendor
+          # :product_serial
+          # :product_name
+          # :product_uuid
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            files = %w[bios_date bios_vendor bios_version board_vendor board_name board_serial
+                       chassis_asset_tag chassis_type sys_vendor product_name product_serial
+                       product_uuid]
+            return unless File.directory?('/sys/class/dmi')
+
+            file_content = Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
+            if files.include?(fact_name.to_s) && file_content
+              @fact_list[fact_name] = file_content.strip
+              chassis_to_name(@fact_list[fact_name]) if fact_name == :chassis_type
+
+            end
+            @fact_list[fact_name]
+          end
+
+          def chassis_to_name(chassis_type)
+            types = ['Other', nil, 'Desktop', 'Low Profile Desktop', 'Pizza Box', 'Mini Tower', 'Tower',
+                     'Portable', 'Laptop', 'Notebook', 'Hand Held', 'Docking Station', 'All in One', 'Sub Notebook',
+                     'Space-Saving', 'Lunch Box', 'Main System Chassis', 'Expansion Chassis', 'SubChassis',
+                     'Bus Expansion Chassis', 'Peripheral Chassis', 'Storage Chassis', 'Rack Mount Chassis',
+                     'Sealed-Case PC', 'Multi-system', 'CompactPCI', 'AdvancedTCA', 'Blade', 'Blade Enclosure',
+                     'Tablet', 'Convertible', 'Detachable']
+            @fact_list[:chassis_type] = types[chassis_type.to_i - 1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/docker_lxc.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DockerLxc < BaseResolver
+      # :virtual
+      # :hypervisor
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      INFO = { 'docker' => 'id', 'lxc' => 'name' }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_cgroup(fact_name) }
+        end
+
+        def read_cgroup(fact_name)
+          output_cgroup = Util::FileHelper.safe_read('/proc/1/cgroup', nil)
+          output_environ = Util::FileHelper.safe_read('/proc/1/environ', nil)
+          return if output_cgroup.nil? || output_environ.nil?
+
+          output_docker = %r{docker/(.+)}.match(output_cgroup)
+          output_lxc = %r{^/lxc/([^/]+)}.match(output_cgroup)
+          lxc_from_environ = /container=lxc/ =~ output_environ
+
+          info, vm = extract_vm_and_info(output_docker, output_lxc, lxc_from_environ)
+          @fact_list[:vm] = vm
+          @fact_list[:hypervisor] = { vm.to_sym => info } if vm
+          @fact_list[fact_name]
+        end
+
+        def extract_vm_and_info(output_docker, output_lxc, lxc_from_environ)
+          vm = nil
+          if output_docker
+            vm = 'docker'
+            info = output_docker[1]
+          end
+          vm = 'lxc' if output_lxc || lxc_from_environ
+          info = output_lxc[1] if output_lxc
+
+          [info ? { INFO[vm] => info } : {}, vm]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/eos_release_resolver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class EosRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_eos_release(fact_name) }
+        end
+
+        def read_eos_release(fact_name)
+          output = Util::FileHelper.safe_read('/etc/Eos-release', nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          output_strings = output.split(' ')
+
+          @fact_list[:name] = output_strings[0]
+          @fact_list[:version] = output_strings[-1]
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/facterversion_resolver.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Facterversion < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_version_file }
+        end
+
+        def read_version_file
+          version_file = ::File.join(ROOT_DIR, 'VERSION')
+          @fact_list[:facterversion] = ::File.read(version_file).chomp('')
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/filesystems_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Filesystems < BaseResolver
+        # :systems
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        @log = Facter::Log.new(self)
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_filesystems(fact_name) }
+          end
+
+          def read_filesystems(fact_name)
+            output = Util::FileHelper.safe_readlines('/proc/filesystems', nil)
+            return unless output
+
+            filesystems = []
+            output.each do |line|
+              tokens = line.split(' ')
+              filesystems << tokens if tokens.size == 1
+            end
+            @fact_list[:systems] = filesystems.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/fips_enabled_resolver.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class FipsEnabled < BaseResolver
+        #:fips_enabled
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        @log = Facter::Log.new(self)
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_fips_file(fact_name) }
+          end
+
+          def read_fips_file(fact_name)
+            file_output = Util::FileHelper.safe_read('/proc/sys/crypto/fips_enabled')
+            @fact_list[:fips_enabled] = file_output.strip == '1'
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/freebsd/freebsd_version_resolver.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class FreebsdVersion < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { freebsd_version_system_call(fact_name) }
+          end
+
+          def freebsd_version_system_call(fact_name)
+            output = Facter::Core::Execution.execute('/bin/freebsd-version -kru', logger: log)
+            return if output.empty?
+
+            build_fact_list(output)
+
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(output)
+            freebsd_version_results = output.split("\n")
+
+            @fact_list[:installed_kernel]   = freebsd_version_results[0].strip
+            @fact_list[:running_kernel]     = freebsd_version_results[1].strip
+            @fact_list[:installed_userland] = freebsd_version_results[2].strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/hostname_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Hostname < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_hostname(fact_name) }
+        end
+
+        def retrieve_hostname(fact_name)
+          output = Facter::Core::Execution.execute('hostname', logger: log)
+
+          # get domain
+          domain = read_domain(output)
+
+          # get hostname
+          hostname = output =~ /(.*?)\./ ? Regexp.last_match(1) : output
+          @fact_list[:hostname] ||= hostname&.strip
+          @fact_list[:domain] ||= domain&.strip
+          @fact_list[:fqdn] ||= "#{@fact_list[:hostname]}.#{@fact_list[:domain]}"
+          @fact_list[fact_name]
+        end
+
+        def read_domain(output)
+          if output =~ /.*?\.(.+$)/
+            domain = Regexp.last_match(1)
+          else
+            file_content = Util::FileHelper.safe_read('/etc/resolv.conf')
+            if file_content =~ /^search\s+(\S+)/
+              domain = Regexp.last_match(1)
+            elsif file_content =~ /^domain\s+(\S+)/
+              domain = Regexp.last_match(1)
+            end
+          end
+          domain
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/identity_resolver.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class PosxIdentity < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_identity(fact_name) }
+        end
+
+        def retrieve_identity(fact_name)
+          require 'etc'
+
+          login_info = Etc.getpwuid
+          @fact_list[:gid] = login_info.gid
+          @fact_list[:group] = Etc.getgrgid(login_info.gid).name
+          @fact_list[:privileged] = login_info.uid.zero?
+          @fact_list[:uid] = login_info.uid
+          @fact_list[:user] = login_info.name
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/load_averages_resolver.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class LoadAverages < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_load_averages_file(fact_name) }
+          end
+
+          def read_load_averages_file(fact_name)
+            output = Util::FileHelper.safe_read('/proc/loadavg')
+            @fact_list[:load_averages] = {}.tap { |h| h['1m'], h['5m'], h['15m'], = output.split.map(&:to_f) }
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/lpar_resolver.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Lpar < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_lpar(fact_name) }
+        end
+
+        def read_lpar(fact_name)
+          output = Facter::Core::Execution.execute('/usr/bin/lparstat -i', logger: log)
+          output.each_line do |line|
+            populate_lpar_data(line.split(':').map(&:strip))
+          end
+          @fact_list[fact_name]
+        end
+
+        def populate_lpar_data(key_value)
+          @fact_list[:lpar_partition_name]   = key_value[1]      if key_value[0] == 'Partition Name'
+          @fact_list[:lpar_partition_number] = key_value[1].to_i if key_value[0] == 'Partition Number'
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/lsb_release_resolver.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class LsbRelease < BaseResolver
+      # :lsb_version
+      # :distributor_id
+      # :description
+      # :release
+      # :codename
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
+        end
+
+        def retrieve_facts(fact_name)
+          lsb_release_installed? if @fact_list[:lsb_release_installed].nil?
+          read_lsb_release_file if @fact_list[:lsb_release_installed]
+          @fact_list[fact_name]
+        end
+
+        def lsb_release_installed?
+          output = Facter::Core::Execution.execute('which lsb_release', logger: log)
+          @fact_list[:lsb_release_installed] = !output.empty?
+        end
+
+        def read_lsb_release_file
+          output = Facter::Core::Execution.execute('lsb_release -a', logger: log)
+          build_fact_list(output)
+        end
+
+        def build_fact_list(info)
+          release_info = info.delete("\t").split("\n").map { |e| e.split(':', 2) }
+
+          result = Hash[*release_info.flatten]
+          result.each { |k, v| @fact_list[k.downcase.gsub(/\s/, '_').to_sym] = v }
+
+          @fact_list[:identifier] = @fact_list[:distributor_id]
+        end
+      end
+    end
+  end
+end