facter 4.0.49 → 4.0.50

data/lib/facter/facts/ol/os/release.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facts
+  module Ol
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = determine_release_version
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def determine_release_version
+          version = Facter::Resolvers::ReleaseFromFirstLine.resolve(:release, release_file: '/etc/oracle-release')
+          version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/openwrt/os/release.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facts
+  module Openwrt
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = from_specific_file || from_os_release
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def from_specific_file
+          version = Facter::Resolvers::SpecificReleaseFile.resolve(:release,
+                                                                   { release_file: '/etc/openwrt_version',
+                                                                     regex: /^(\d+.\d+.*)/ })
+          Facter::Util::Facts.release_hash_from_matchdata(version)
+        end
+
+        def from_os_release
+          version = Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/ovs/os/release.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facts
+  module Ovs
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = determine_release_version
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def determine_release_version
+          version = Facter::Resolvers::ReleaseFromFirstLine.resolve(:release, release_file: '/etc/ovs-release')
+          version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/photon/os/release.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facts
+  module Photon
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = from_specific_file || from_os_release
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def from_specific_file
+          version = Facter::Resolvers::SpecificReleaseFile.resolve(:release,
+                                                                   { release_file: '/etc/lsb-release',
+                                                                     regex: /DISTRIB_RELEASE="(\d+)\.(\d+)/ })
+          return if version.nil? || version[1].nil? || version[2].nil?
+
+          major = version[1].to_s
+          minor = version[2].to_s
+          version_data = major + '.' + minor
+
+          {
+            'full' => version_data,
+            'major' => major,
+            'minor' => minor
+          }
+        end
+
+        def from_os_release
+          version = Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/rhel/os/release.rb

@@ -21,14 +21,7 @@ module Facts
           version = Facter::Resolvers::RedHatRelease.resolve(:version)
           version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
 
-          return unless version
-
-          versions = version.split('.')
-          fact_value = {}
-          fact_value['full'] = version
-          fact_value['major'] = versions[0]
-          fact_value['minor'] = versions[1] if versions[1]
-          fact_value
+          Facter::Util::Facts.release_hash_from_string(version)
         end
       end
     end

data/lib/facter/facts/slackware/os/release.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facts
+  module Slackware
+    module Os
+      class Release
+        FACT_NAME = 'os.release'
+        ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
+
+        def call_the_resolver
+          version = from_specific_file || from_os_release
+
+          return Facter::ResolvedFact.new(FACT_NAME, nil) unless version
+
+          [Facter::ResolvedFact.new(FACT_NAME, version),
+           Facter::ResolvedFact.new(ALIASES.first, version['major'], :legacy),
+           Facter::ResolvedFact.new(ALIASES.last, version['full'], :legacy)]
+        end
+
+        def from_specific_file
+          version = Facter::Resolvers::SpecificReleaseFile.resolve(:release,
+                                                                   { release_file: '/etc/slackware-version',
+                                                                     regex: /Slackware ([0-9.]+)/ })
+          Facter::Util::Facts.release_hash_from_matchdata(version)
+        end
+
+        def from_os_release
+          version = Facter::Resolvers::OsRelease.resolve(:version_id)
+
+          Facter::Util::Facts.release_hash_from_string(version)
+        end
+      end
+    end
+  end
+end

data/lib/facter/framework/config/config_reader.rb

@@ -33,10 +33,17 @@ module Facter
 
       def refresh_config(config_path)
         @conf = File.readable?(config_path) ? Hocon.load(config_path) : {}
+      rescue StandardError => e
+        log.warn("Facter failed to read config file #{config_path} with the following error: #{e.message}")
+        @conf = {}
       end
 
       private
 
+      def log
+        @log ||= Log.new(self)
+      end
+
       def default_path
         os = OsDetector.instance.identifier
 

data/lib/facter/framework/config/fact_groups.rb

@@ -24,6 +24,9 @@ module Facter
       fact_list = []
 
       @block_list.each do |group_name|
+        # legacy is a special group and does not need to be broken into facts
+        next if group_name == 'legacy'
+
         facts_for_block = @groups[group_name]
 
         fact_list += facts_for_block || [group_name]

data/lib/facter/framework/core/fact_loaders/external_fact_loader.rb

@@ -10,10 +10,6 @@ module Facter
       @external_facts = load_external_facts
     end
 
-    def all_facts
-      @all_facts ||= Utils.deep_copy(custom_facts + external_facts)
-    end
-
     private
 
     def load_custom_facts

data/lib/facter/framework/core/fact_loaders/fact_loader.rb

@@ -83,6 +83,8 @@ module Facter
     def block_facts(facts, options)
       blocked_facts = options[:blocked_facts] || []
 
+      facts.reject! { |fact| fact.type == :legacy } if options[:block_list]&.include?('legacy')
+
       reject_list_core, reject_list_legacy = construct_reject_lists(blocked_facts, facts)
 
       facts = facts.reject do |fact|

data/lib/facter/framework/detector/os_detector.rb

@@ -64,7 +64,14 @@ class OsDetector
     Facter::Resolvers::OsRelease.resolve(:id_like)
   end
 
+  def detect_based_on_release_file
+    @identifier = :devuan if File.readable?('/etc/devuan_version')
+  end
+
   def detect_distro
+    detect_based_on_release_file
+    return @identifier if @identifier
+
     [Facter::Resolvers::OsRelease,
      Facter::Resolvers::RedHatRelease,
      Facter::Resolvers::SuseRelease].each do |resolver|

data/lib/facter/resolvers/aio_agent_version.rb

@@ -8,7 +8,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_agent_version }
         end
 

data/lib/facter/resolvers/aix/architecture.rb

@@ -9,7 +9,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_architecture(fact_name) }
         end
 

data/lib/facter/resolvers/aix/disks.rb

@@ -9,7 +9,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { execute_lspv(fact_name) }
           end
 

data/lib/facter/resolvers/aix/ffi/ffi.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      module FFI
+        RTM_IFINFO = 0xe
+        RTM_NEWADDR = 0xc
+
+        RTAX_DST = 0
+        RTAX_GATEWAY = 1
+        RTAX_NETMASK = 2
+        RTAX_GENMASK = 3
+        RTAX_IFP = 4
+        RTAX_IFA = 5
+        RTAX_AUTHOR = 6
+        RTAX_BRD = 7
+        RTAX_MAX = 8
+
+        RTA_DST = 0x1
+        RTA_GATEWAY = 0x2
+        RTA_NETMASK = 0x4
+        RTA_GENMASK = 0x8
+        RTA_IFP = 0x10
+        RTA_IFA = 0x20
+        RTA_AUTHOR = 0x40
+        RTA_BRD = 0x80
+        RTA_DOWNSTREAM = 0x100
+
+        AF_UNSPEC = 0
+        AF_INET = 2
+        AF_INET6 = 24
+        AF_MAX = 30
+
+        INET_ADDRSTRLEN = 16
+        INET6_ADDRSTRLEN = 46
+
+        RTAX_LIST = [
+          RTAX_DST,
+          RTAX_GATEWAY,
+          RTAX_NETMASK,
+          RTAX_GENMASK,
+          RTAX_IFP,
+          RTAX_IFA,
+          RTAX_AUTHOR,
+          RTAX_BRD
+        ].freeze
+
+        RTA_LIST = [
+          RTA_DST,
+          RTA_GATEWAY,
+          RTA_NETMASK,
+          RTA_GENMASK,
+          RTA_IFP,
+          RTA_IFA,
+          RTA_AUTHOR,
+          RTA_BRD,
+          RTA_DOWNSTREAM
+        ].freeze
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/ffi/ffi_helper.rb

@@ -1,34 +1,160 @@
 # frozen_string_literal: true
 
 require 'ffi'
-
+require_relative 'structs'
+require_relative 'ffi'
 module Facter
-  module Aix
-    module FfiHelper
-      KINFO_GET_AVENRUN = 1
-      KINFO_READ        = 8 << 8
+  module Resolvers
+    module Aix
+      module FfiHelper
+        KINFO_GET_AVENRUN = 1
+        KINFO_READ        = 8 << 8
+        KINFO_RT          = 1 << 8
+        KINFO_RT_IFLIST   = KINFO_RT | 3
 
-      module Libc
-        extend FFI::Library
+        module Libc
+          extend ::FFI::Library
 
-        RTLD_LAZY   = 0x00000004
-        RTLD_GLOBAL = 0x00010000
-        RTLD_MEMBER = 0x00040000
+          RTLD_LAZY   = 0x00000004
+          RTLD_GLOBAL = 0x00010000
+          RTLD_MEMBER = 0x00040000
 
-        @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
-        ffi_lib 'libc.a(shr.o)'
+          @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
+          ffi_lib 'libc.a(shr.o)'
 
-        attach_function :getkerninfo, %i[int pointer pointer int], :int
-      end
+          attach_function :getkerninfo, %i[int pointer pointer int], :int
+          attach_function :inet_ntop, %i[int pointer pointer uint], :string
+        end
+
+        def self.read_load_averages
+          averages = ::FFI::MemoryPointer.new(:long_long, 3)
+          averages_size = ::FFI::MemoryPointer.new(:int, 1)
+          averages_size.write_int(averages.size)
+
+          return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+
+          averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+        end
+
+        def self.read_interfaces
+          ksize = Libc.getkerninfo(KINFO_RT_IFLIST, nil, nil, 0)
+
+          log.debug('getkerninfo call was unsuccessful') if ksize.zero?
+
+          ksize_ptr = ::FFI::MemoryPointer.new(:int, ksize.size)
+          ksize_ptr.write_int(ksize)
+
+          result_ptr = ::FFI::MemoryPointer.new(:char, ksize)
+
+          res = Libc.getkerninfo(KINFO_RT_IFLIST, result_ptr, ksize_ptr, 0)
+          log.debug('getkerninfo call was unsuccessful') if res == -1
+
+          cursor = 0
+
+          interfaces = {}
+          while cursor < ksize_ptr.read_int
+            hdr = FFI::IfMsghdr.new(result_ptr + cursor)
+
+            case hdr[:ifm_type]
+            when FFI::RTM_IFINFO
+              link_addr = FFI::SockaddrDl.new(hdr.to_ptr + hdr.size)
+
+              interface_name = link_addr[:sdl_data].to_s[0, link_addr[:sdl_nlen]]
+              interfaces[interface_name] ||= {}
+
+            when FFI::RTM_NEWADDR
+              addresses = {}
+              addr_cursor = cursor + hdr.size
+              FFI::RTAX_LIST.each do |key|
+                xand = hdr[:ifm_addrs] & FFI::RTA_LIST[key]
+                next unless xand != 0
+
+                sockaddr = FFI::Sockaddr.new(result_ptr + addr_cursor)
+                addresses[key] = sockaddr
+                roundup_nr = roundup(sockaddr)
+                addr_cursor += roundup_nr
+              end
+
+              family = FFI::AF_UNSPEC
+
+              addresses.each do |_k, addr|
+                if family != FFI::AF_UNSPEC &&
+                   addr[:sa_family] != FFI::AF_UNSPEC &&
+                   family != addr[:sa_family]
+                  family = FFI::AF_MAX
+                  break
+                end
+                family = addr[:sa_family]
+              end
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len]
+                addresses[FFI::RTAX_NETMASK][:sa_family] = family
+                netmask = address_to_string(addresses[FFI::RTAX_NETMASK])
+              end
+
+              address = address_to_string(addresses[FFI::RTAX_IFA]) if addresses[FFI::RTAX_IFA][:sa_len]
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len] && addresses[FFI::RTAX_IFA][:sa_len]
+                network = address_to_string(addresses[FFI::RTAX_IFA], addresses[FFI::RTAX_NETMASK])
+              end
+
+              bindings = family == FFI::AF_INET ? :bindings : :bindings6
+              interfaces[interface_name][bindings] ||= []
+              interfaces[interface_name][bindings] << {
+                netmask: netmask.read_string,
+                address: address.read_string,
+                network: network.read_string
+              }
+            else
+              log.debug("got an unknown RT_IFLIST message: #{hdr[:ifm_type]}")
+            end
+
+            cursor += hdr[:ifm_msglen]
+          end
+
+          interfaces
+        end
+
+        def self.roundup(sockaddr)
+          if sockaddr[:sa_len].positive?
+            1 + ((sockaddr[:sa_len] - 1) | (1.size - 1))
+          else
+            1.size
+          end
+        end
+
+        def self.address_to_string(sockaddr, mask = nil)
+          if sockaddr[:sa_family] == FFI::AF_INET
+            in_addr_ip = FFI::SockaddrIn.new(sockaddr.to_ptr)
+
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn.new(mask.to_ptr)
+              in_addr_ip[:sin_addr][:s_addr] &= in_addr_mask[:sin_addr][:s_addr]
+            end
+
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET, in_addr_ip[:sin_addr].to_ptr, buffer, 16)
+
+            buffer
+          elsif sockaddr[:sa_family] == FFI::AF_INET6
+            in_addr_ip = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+              16.times do |i|
+                in_addr_ip[:sin6_addr][:u6_addr8][i] &= in_addr_mask[:sin6_addr][:u6_addr8][i]
+              end
+            end
 
-      def self.read_load_averages
-        averages = FFI::MemoryPointer.new(:long_long, 3)
-        averages_size = FFI::MemoryPointer.new(:int, 1)
-        averages_size.write_int(averages.size)
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET6_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET6, in_addr_ip[:sin6_addr].to_ptr, buffer, 16)
 
-        return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+            buffer
+          end
+        end
 
-        averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+        def self.log
+          @log ||= Log.new(self)
+        end
       end
     end
   end