facter 4.0.50 → 4.2.0

data/lib/facter/resolvers/linux/networking.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Networking < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
+
+            @fact_list[fact_name]
+          end
+
+          def retrieve_network_info(fact_name)
+            add_info_from_socket_reader
+            add_info_from_routing_table
+            retrieve_primary_interface
+            Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+            add_flags
+            @fact_list[fact_name]
+          end
+
+          def add_info_from_socket_reader
+            @fact_list[:interfaces] = Facter::Util::Linux::SocketParser.retrieve_interfaces(log)
+            mtu_and_indexes = interfaces_mtu_and_index
+
+            @fact_list[:interfaces].keys.each do |interface_name|
+              mtu(interface_name, mtu_and_indexes)
+              dhcp(interface_name, mtu_and_indexes)
+
+              @log.debug("Found interface #{interface_name} with #{@fact_list[:interfaces][interface_name]}")
+            end
+          end
+
+          def interfaces_mtu_and_index
+            mtu_and_indexes = {}
+            output = Facter::Core::Execution.execute('ip link show', logger: log)
+            output.each_line do |line|
+              next unless line.include?('mtu')
+
+              parse_ip_command_line(line, mtu_and_indexes)
+            end
+            log.debug("Associated MTU and index in ip command: #{mtu_and_indexes}")
+            mtu_and_indexes
+          end
+
+          def parse_ip_command_line(line, mtu_and_indexes)
+            mtu = line.match(/mtu (\d+)/)&.captures&.first&.to_i
+            index_tokens = line.split(':')
+            index = index_tokens[0].strip
+            # vlans are displayed as <vlan_name>@<physical_interface>
+            name = index_tokens[1].split('@').first.strip
+            mtu_and_indexes[name] = { index: index, mtu: mtu }
+          end
+
+          def mtu(interface_name, mtu_and_indexes)
+            mtu = mtu_and_indexes.dig(interface_name, :mtu)
+            @fact_list[:interfaces][interface_name][:mtu] = mtu unless mtu.nil?
+          end
+
+          def dhcp(interface_name, mtu_and_indexes)
+            dhcp = Facter::Util::Linux::Dhcp.dhcp(interface_name, mtu_and_indexes.dig(interface_name, :index), log)
+            @fact_list[:interfaces][interface_name][:dhcp] = dhcp unless dhcp.nil?
+          end
+
+          def add_info_from_routing_table
+            routes4, routes6 = Facter::Util::Linux::RoutingTable.read_routing_table(log)
+            compare_ips(routes4, :bindings)
+            compare_ips(routes6, :bindings6)
+          end
+
+          def add_flags
+            flags = Facter::Util::Linux::IfInet6.read_flags
+            flags.each_pair do |iface, ips|
+              next unless @fact_list[:interfaces].key?(iface)
+
+              ips.each_pair do |ip, ip_flags|
+                next unless @fact_list[:interfaces][iface].key?(:bindings6)
+
+                @fact_list[:interfaces][iface][:bindings6].each do |binding|
+                  next unless binding[:address] == ip
+
+                  binding[:flags] = ip_flags
+                end
+              end
+            end
+          end
+
+          def compare_ips(routes, binding_key)
+            routes.each do |route|
+              next unless @fact_list[:interfaces].key?(route[:interface])
+
+              interface_data = @fact_list[:interfaces][route[:interface]]
+              add_binding_if_missing(interface_data, binding_key, route)
+            end
+          end
+
+          def add_binding_if_missing(interface_data, binding_key, route)
+            interface_binding = interface_data[binding_key]
+
+            if interface_binding.nil?
+              interface_data[binding_key] = [{ address: route[:ip] }]
+            elsif interface_binding.none? { |binding| binding[:address] == route[:ip] }
+              interface_binding << { address: route[:ip] }
+            end
+          end
+
+          def retrieve_primary_interface
+            primary_helper = Facter::Util::Resolvers::Networking::PrimaryInterface
+            primary_interface = primary_helper.read_from_proc_route
+            primary_interface ||= primary_helper.read_from_ip_route
+            primary_interface ||= primary_helper.find_in_interfaces(@fact_list[:interfaces])
+
+            @fact_list[:primary_interface] = primary_interface
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/macosx/mountpoints.rb

@@ -21,7 +21,7 @@ module Facter
               device = fs.name
               filesystem = fs.mount_type
               path = fs.mount_point
-              options = fs.options.split(',').map(&:strip).map { |o| o == 'rootfs' ? 'root' : o }
+              options = read_options(fs.options)
 
               mounts[path] = read_stats(path).tap do |hash|
                 hash[:device] = device
@@ -53,6 +53,19 @@ module Facter
               used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
             }
           end
+
+          def read_options(options)
+            options_map = {
+              'read-only' => 'readonly',
+              'asynchronous' => 'async',
+              'synchronous' => 'noasync',
+              'quotas' => 'quota',
+              'rootfs' => 'root',
+              'defwrite' => 'deferwrites'
+            }
+
+            options.split(',').map(&:strip).map { |o| options_map.key?(o) ? options_map[o] : o }
+          end
         end
       end
     end

data/lib/facter/resolvers/macosx/processor.rb

@@ -9,12 +9,17 @@ module Facter
         ITEMS = { logical_count: 'hw.logicalcpu_max',
                   physical_count: 'hw.physicalcpu_max',
                   brand: 'machdep.cpu.brand_string',
-                  speed: 'hw.cpufrequency_max' }.freeze
+                  speed: 'hw.cpufrequency_max',
+                  cores_per_socket: 'machdep.cpu.core_count',
+                  threads_per_core: 'machdep.cpu.thread_count' }.freeze
+
         class << self
           # :logicalcount
           # :models
           # :physicalcount
           # :speed
+          # :cores_per_socket
+          # :threads_per_core
 
           private
 
@@ -33,6 +38,8 @@ module Facter
             build_physical_count(processors_data[1])
             build_models(processors_data[2])
             build_speed(processors_data[3])
+            build_cores_per_socket(processors_data[4])
+            build_threads_per_core(processors_data[5], processors_data[4])
           end
 
           def build_logical_count(count)
@@ -51,6 +58,14 @@ module Facter
           def build_speed(value)
             @fact_list[:speed] = value.split(': ')[1].to_i
           end
+
+          def build_cores_per_socket(count)
+            @fact_list[:cores_per_socket] = count.split(': ')[1].to_i
+          end
+
+          def build_threads_per_core(number_of_threads, number_of_cores)
+            @fact_list[:threads_per_core] = number_of_threads.split(': ')[1].to_i / number_of_cores.split(': ')[1].to_i
+          end
         end
       end
     end

data/lib/facter/resolvers/mountpoints.rb

@@ -67,10 +67,24 @@ module Facter
         end
 
         def get_mount_sizes(mount)
-          stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(mount[:path])
+          begin
+            stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(mount[:path])
+            get_bytes_data(mount, stats)
+          rescue Sys::Filesystem::Error => e
+            @log.debug("Could not get stats for mountpoint #{mount[:path]}, got #{e}")
+            mount[:size_bytes] = mount[:available_bytes] = mount[:used_bytes] = 0
+          end
+
+          populate_mount(mount)
+        end
 
-          get_bytes_data(mount, stats)
+        def get_bytes_data(mount, stats)
+          mount[:size_bytes] = stats.bytes_total.abs
+          mount[:available_bytes] = stats.bytes_available.abs
+          mount[:used_bytes] = stats.bytes_used.abs
+        end
 
+        def populate_mount(mount)
           total_bytes = mount[:used_bytes] + mount[:available_bytes]
           mount[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(mount[:used_bytes], total_bytes)
 
@@ -78,12 +92,6 @@ module Facter
           mount[:available] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:available_bytes])
           mount[:used] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:used_bytes])
         end
-
-        def get_bytes_data(mount, stats)
-          mount[:size_bytes] = stats.bytes_total.abs
-          mount[:available_bytes] = stats.bytes_available.abs
-          mount[:used_bytes] = stats.bytes_used.abs
-        end
       end
     end
   end

data/lib/facter/resolvers/networking.rb

@@ -42,7 +42,7 @@ module Facter
 
         def parse_interfaces_response(response)
           parsed_interfaces_data = {}
-          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_\.]+): /)[1..-1]]
 
           interfaces_data.each do |interface_name, raw_data|
             parsed_interface_data = {}
@@ -63,7 +63,8 @@ module Facter
         end
 
         def extract_mac(raw_data, parsed_interface_data)
-          mac = raw_data.match(/(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/)&.captures&.first
+          mac = raw_data.match(/(?:ether|lladdr)\s+((?:\w?\w:){5}\w?\w)|(?:infiniband)\s+((?:\w?\w:){19}\w?\w)/)
+                       &.captures&.compact&.first
           parsed_interface_data[:mac] = mac unless mac.nil?
         end
 

data/lib/facter/resolvers/partitions.rb

@@ -109,7 +109,7 @@ module Facter
 
           output = Facter::Core::Execution.execute("which #{command}", logger: log)
 
-          blkid_and_lsblk[:command_exists_key] = !output.empty?
+          blkid_and_lsblk[command_exists_key] = !output.empty?
         end
 
         def execute_and_extract_blkid_info

data/lib/facter/resolvers/processors_lscpu.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Lscpu < BaseResolver
+        init_resolver
+
+        ITEMS = { threads_per_core: "-e 'Thread(s)'",
+                  cores_per_socket: "-e 'Core(s)'" }.freeze
+
+        class << self
+          #:cores_per_socket
+          #:threads_per_core
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_cpuinfo(fact_name) }
+          end
+
+          def read_cpuinfo(fact_name)
+            lscpu_output = Facter::Core::Execution.execute("lscpu | grep #{ITEMS.values.join(' ')}", logger: log)
+            build_fact_list(lscpu_output.split("\n"))
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(processors_data)
+            build_threads_per_core(processors_data[0])
+            build_cores_per_socket(processors_data[1])
+          end
+
+          def build_threads_per_core(index)
+            @fact_list[:threads_per_core] = index.split(': ')[1].to_i
+          end
+
+          def build_cores_per_socket(index)
+            @fact_list[:cores_per_socket] = index.split(': ')[1].to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/redhat_release.rb

@@ -6,6 +6,8 @@ module Facter
       # :name
       # :version
       # :codename
+      # :description
+      # :distributor_id
 
       init_resolver
 
@@ -26,29 +28,43 @@ module Facter
         end
 
         def build_fact_list(output)
+          @fact_list[:description] = output.strip
           output_strings = output.split('release')
           output_strings.map!(&:strip)
-          version_codename = output_strings[1].split(' ')
-
-          @fact_list[:name] = name(output_strings[0])
-          @fact_list[:version] = version_codename[0]&.strip
-
-          codename = version_codename[1]&.strip
-          @fact_list[:codename] = codename ? codename.gsub(/[()]/, '') : nil
 
+          @fact_list[:codename] = codename(output)
+          @fact_list[:distributor_id] = distributor_id(output_strings[0])
+          @fact_list[:name] = release_name(output_strings[0])
+          @fact_list[:version] = version(output_strings)
           @fact_list[:identifier] = identifier(@fact_list[:name])
         end
 
-        def name(name)
-          name.strip.split(' ')[0..1].join
+        def release_name(value)
+          value.split.reject { |el| el.casecmp('linux').zero? }[0..1].join
         end
 
-        def identifier(name)
-          identifier = name.strip.downcase
-          identifier = 'rhel' if @fact_list[:name].strip.casecmp('Red Hat Enterprise Linux')
+        def identifier(value)
+          identifier = value.downcase
+          identifier = 'rhel' if @fact_list[:name].casecmp('Red Hat Enterprise Linux')
 
           identifier
         end
+
+        def codename(value)
+          matched_data = value.match(/.*release.*(\(.*\)).*/)
+          return unless matched_data
+
+          codename = (matched_data[1] || '').gsub(/\(|\)/, '')
+          codename.empty? ? nil : codename
+        end
+
+        def version(value)
+          value[1].split.first
+        end
+
+        def distributor_id(value)
+          value.split.reject { |el| el.casecmp('linux').zero? }.join
+        end
       end
     end
   end

data/lib/facter/resolvers/ruby.rb

@@ -13,7 +13,7 @@ module Facter
         end
 
         def retrieve_ruby_information(fact_name)
-          @fact_list[:sitedir] = RbConfig::CONFIG['sitelibdir']
+          @fact_list[:sitedir] = RbConfig::CONFIG['sitelibdir'] if RbConfig::CONFIG['sitedir']
           @fact_list[:platform] = RUBY_PLATFORM
           @fact_list[:version] = RUBY_VERSION
           @fact_list[fact_name]

data/lib/facter/resolvers/selinux.rb

@@ -13,21 +13,21 @@ module Facter
         end
 
         def retrieve_facts(fact_name)
-          mountpoint = read_mounts_file if @fact_list[:enabled].nil?
+          mountpoint = selinux_mountpoint
+
+          @fact_list[:enabled] = !mountpoint.empty? && read_selinux_config
           read_other_selinux_facts(mountpoint) if @fact_list[:enabled]
 
           @fact_list[fact_name]
         end
 
-        def read_mounts_file
+        def selinux_mountpoint
           output = Facter::Core::Execution.execute('cat /proc/self/mounts', logger: log)
-          @fact_list[:enabled] = false
           mountpoint = ''
 
           output.each_line do |line|
             next unless line =~ /selinuxfs/
 
-            @fact_list[:enabled] = true
             mountpoint = line.split("\s")[1]
             break
           end
@@ -35,8 +35,6 @@ module Facter
         end
 
         def read_other_selinux_facts(mountpoint)
-          return unless read_selinux_config
-
           enforce_file = "#{mountpoint}/enforce"
           policy_file = "#{mountpoint}/policyvers"
 
@@ -60,7 +58,7 @@ module Facter
             @fact_list[:config_policy] = line.split('=').last.strip if line =~ /^SELINUXTYPE=/
           end
 
-          true unless file_lines.empty?
+          !file_lines.empty? ? true : false
         end
       end
     end

data/lib/facter/resolvers/solaris/ffi/functions.rb

@@ -6,7 +6,7 @@ module Facter
       module FFI
         module Ioctl
           extend ::FFI::Library
-          ffi_lib ::FFI::Library::LIBC, '/usr/lib/libsocket.so'
+          ffi_lib ::FFI::Library::LIBC, 'socket'
 
           attach_function :ioctl_base, :ioctl, %i[int int pointer], :int
           attach_function :open_socket, :socket, %i[int int int], :int

data/lib/facter/resolvers/solaris/ffi/structs.rb

@@ -111,6 +111,18 @@ module Facter
             self[:sin_addr][:s_addr]
           end
         end
+
+        class In6Addr < ::FFI::Struct
+          layout :s_addr, [:uint32_t, 4]
+        end
+
+        class SockaddrIn6 < ::FFI::Struct
+          layout  :sin6_family, :sa_family_t,
+                  :sin6_port, :in_port_t,
+                  :sin6_flowinfo, :uint32_t,
+                  :sin6_addr, In6Addr,
+                  :sin6_scope_id, :uint32_t
+        end
       end
     end
   end