facter 4.0.28

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/ec2.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Facter
+  module Resolvers
+    class Ec2 < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      EC2_METADATA_ROOT_URL = 'http://169.254.169.254/latest/meta-data/'
+      EC2_USERDATA_ROOT_URL = 'http://169.254.169.254/latest/user-data/'
+      EC2_CONNECTION_TIMEOUT = 0.6
+      EC2_SESSION_TIMEOUT = 5
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = {}
+          query_for_metadata(EC2_METADATA_ROOT_URL, @fact_list[:metadata])
+          @fact_list[:userdata] = get_data_from(EC2_USERDATA_ROOT_URL).strip
+          @fact_list[fact_name]
+        end
+
+        def query_for_metadata(url, container)
+          metadata = get_data_from(url)
+          metadata.each_line do |line|
+            next if line.empty?
+
+            http_path_component = build_path_compoent(line)
+            next if http_path_component == 'security-credentials/'
+
+            if http_path_component.end_with?('/')
+              child = {}
+              child[http_path_component] = query_for_metadata("#{url}#{http_path_component}", child)
+              child.reject! { |key, _info| key == http_path_component }
+              name = http_path_component.chomp('/')
+              container[name] = child
+            else
+              container[http_path_component] = get_data_from("#{url}#{http_path_component}").strip
+            end
+          end
+        end
+
+        def build_path_compoent(line)
+          array_match = /^(\d+)=.*$/.match(line)
+          array_match ? "#{array_match[1]}/" : line.strip
+        end
+
+        def get_data_from(url)
+          parsed_url = URI.parse(url)
+          http = Net::HTTP.new(parsed_url.host)
+          http.read_timeout = determine_session_timeout
+          http.open_timeout = EC2_CONNECTION_TIMEOUT
+          resp = http.get(parsed_url.path)
+          response_code_valid?(resp.code) ? resp.body : ''
+        rescue StandardError => e
+          log.debug("Trying to connect to #{url} but got: #{e.message}")
+          ''
+        end
+
+        def response_code_valid?(http_code)
+          http_code.to_i.equal?(200)
+        end
+
+        def determine_session_timeout
+          session_env = ENV['EC2_SESSION_TIMEOUT']
+          session_env ? session_env.to_i : EC2_SESSION_TIMEOUT
+        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/ffi/ffi_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Freebsd
+    module FfiHelper
+      module Libc
+        extend FFI::Library
+
+        ffi_lib 'c'
+        attach_function :sysctlbyname, %i[string pointer pointer pointer size_t], :int
+      end
+
+      def self.sysctl_by_name(type, name)
+        oldp = FFI::Pointer::NULL
+        oldlenp = FFI::MemoryPointer.new(:size_t)
+
+        newp = FFI::Pointer::NULL
+        newlenp = 0
+
+        if type == :string
+          res = Libc.sysctlbyname(name, oldp, oldlenp, newp, newlenp)
+          return nil if res.negative?
+        else
+          oldlenp.write(:size_t, FFI.type_size(type))
+        end
+
+        oldp = FFI::MemoryPointer.new(:uint8_t, oldlenp.read(:size_t))
+        res = Libc.sysctlbyname(name, oldp, oldlenp, newp, newlenp)
+        return nil if res.negative?
+
+        case type
+        when :string
+          oldp.read_string
+        else
+          oldp.read(type)
+        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/freebsd/geom_resolver.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Geom < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+            require 'rexml/document'
+
+            read_disks
+            read_partitions
+
+            @fact_list[fact_name]
+          end
+
+          def read_disks
+            @fact_list[:disks] = {}
+
+            each_geom_class_provider('DISK') do |provider|
+              name = provider.get_text('./name').value
+
+              @fact_list[:disks][name] = %i[read_model read_serial_number read_size].map do |x|
+                send(x, provider)
+              end.inject(:merge)
+            end
+          end
+
+          def read_partitions
+            @fact_list[:partitions] = {}
+
+            each_geom_class_provider('PART') do |provider|
+              name = provider.get_text('./name').value
+
+              @fact_list[:partitions][name] = %i[read_partlabel read_partuuid read_size].map do |x|
+                send(x, provider)
+              end.inject(:merge)
+            end
+          end
+
+          def each_geom_class_provider(geom_class_name, &block)
+            REXML::XPath.each(geom_topology, "/mesh/class[name/text() = '#{geom_class_name}']/geom/provider", &block)
+          end
+
+          def read_size(provider)
+            res = {}
+            return res unless (mediasize = provider.get_text('mediasize'))
+
+            mediasize = Integer(mediasize.value)
+
+            res[:size_bytes] = mediasize
+            res[:size] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(mediasize)
+            res
+          end
+
+          def read_model(provider)
+            res = {}
+            return res unless (model = provider.get_text('./config/descr'))
+
+            res[:model] = model.value
+            res
+          end
+
+          def read_partlabel(provider)
+            res = {}
+            return res unless (rawuuid = provider.get_text('./config/label'))
+
+            res[:partlabel] = rawuuid.value
+            res
+          end
+
+          def read_partuuid(provider)
+            res = {}
+            return res unless (rawuuid = provider.get_text('./config/rawuuid'))
+
+            res[:partuuid] = rawuuid.value
+            res
+          end
+
+          def read_serial_number(provider)
+            res = {}
+            return res unless (serial_number = provider.get_text('./config/ident'))
+
+            res[:serial_number] = serial_number.value
+            res
+          end
+
+          def geom_topology
+            @geom_topology ||= REXML::Document.new(geom_confxml)
+          end
+
+          def geom_confxml
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'kern.geom.confxml')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/freebsd/processors.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'resolvers/bsd/processors'
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Processors < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
+          end
+
+          def collect_processors_info(fact_name)
+            require "#{ROOT_DIR}/lib/resolvers/freebsd/ffi/ffi_helper"
+
+            @fact_list[:logical_count] = logical_count
+            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            @fact_list[:speed] = speed * 1000 * 1000 if speed
+
+            @fact_list[fact_name]
+          end
+
+          def model
+            @model ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'hw.model')
+          end
+
+          def logical_count
+            @logical_count ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.ncpu')
+          end
+
+          def speed
+            @speed ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.clockrate')
+          end
+        end
+      end
+    end
+  end
+end