facter 4.0.32 → 4.0.37

data/lib/facter/resolvers/hostname_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Hostname < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
       class << self
         private

data/lib/facter/resolvers/identity_resolver.rb

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     class PosxIdentity < BaseResolver
       @log = Facter::Log.new(self)
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class DockerUptime < BaseResolver
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { detect_uptime(fact_name) }
+          end
+
+          def detect_uptime(fact_name)
+            days, hours, minutes, seconds = extract_uptime_from_docker
+            total_seconds = convert_to_seconds(days, hours, minutes, seconds)
+            @fact_list = Utils::UptimeHelper.create_uptime_hash(total_seconds)
+
+            @fact_list[fact_name]
+          end
+
+          def extract_uptime_from_docker
+            # time format [dd-][hh:]mm:ss
+            time = Facter::Core::Execution.execute('ps -o etime= -p "1"', logger: log)
+            extracted_time = time.split(/[-:]/)
+
+            reversed_time = extracted_time.reverse
+            seconds = reversed_time[0].to_i
+            minutes = reversed_time[1].to_i
+            hours = reversed_time[2].to_i
+            days = reversed_time[3].to_i
+
+            [days, hours, minutes, seconds]
+          end
+
+          def convert_to_seconds(days, hours, minutes, seconds)
+            days * 24 * 3600 + hours * 3600 + minutes * 60 + seconds
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/{load_averages_resolver.rb → linux/load_averages.rb}

@@ -4,8 +4,6 @@ module Facter
   module Resolvers
     module Linux
       class LoadAverages < BaseResolver
-        @log = Facter::Log.new(self)
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private

data/lib/facter/resolvers/load_averages.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class LoadAverages < BaseResolver
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
+        end
+
+        def read_load_averages(fact_name)
+          require_relative 'utils/ffi/load_averages'
+
+          log.debug('loading cpu load averages')
+          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Utils::Ffi::LoadAverages.read_load_averages).to_h
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/lpar_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Lpar < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/lsb_release_resolver.rb

@@ -9,7 +9,6 @@ module Facter
       # :release
       # :codename
 
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/lspci.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Lspci < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       REGEX_VALUES = { 'VirtualBox' => 'virtualbox', 'XenSource' => 'xenhvm',
@@ -28,6 +27,8 @@ module Facter
 
         def retrieve_vm(output)
           output.each_line { |line| REGEX_VALUES.each { |key, value| return value if line =~ /#{key}/ } }
+
+          nil
         end
       end
     end

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

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Macosx
       class DmiBios < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
 
         class << self

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

@@ -5,7 +5,6 @@ module Facter
     module Macosx
       class Filesystems < BaseResolver
         # :macosx_filesystems
-        @semaphore = Mutex.new
         @fact_list ||= {}
 
         class << self
@@ -17,11 +16,7 @@ module Facter
 
           def read_filesystems(fact_name)
             output = Facter::Core::Execution.execute('mount', logger: log)
-            filesystems = []
-            output.each_line do |line|
-              filesystem = line.match(/\(([a-z]+)\,*/).to_s
-              filesystems << filesystem[1..-2]
-            end
+            filesystems = output.scan(/\(([a-z]+)\,*/).flatten
             @fact_list[:macosx_filesystems] = filesystems.uniq.sort.join(',')
             @fact_list[fact_name]
           end

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

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Macosx
       class LoadAverages < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private

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

@@ -5,7 +5,6 @@ module Facter
     module Macosx
       class Mountpoints < BaseResolver
         include Facter::FilesystemHelper
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private
@@ -16,6 +15,7 @@ module Facter
 
           def read_mounts
             mounts = {}
+
             FilesystemHelper.read_mountpoints.each do |fs|
               device = fs.name
               filesystem = fs.mount_type
@@ -36,8 +36,8 @@ module Facter
             begin
               stats = FilesystemHelper.read_mountpoint_stats(path)
               size_bytes = stats.bytes_total
-              used_bytes = stats.bytes_used
-              available_bytes = size_bytes - used_bytes
+              available_bytes = stats.bytes_available
+              used_bytes = size_bytes - available_bytes
             rescue Sys::Filesystem::Error
               size_bytes = used_bytes = available_bytes = 0
             end

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

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Macosx
       class Processors < BaseResolver
-        @semaphore = Mutex.new
         @fact_list = {}
         ITEMS = { logical_count: 'hw.logicalcpu_max',
                   physical_count: 'hw.physicalcpu_max',

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

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Macosx
       class SwapMemory < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private

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

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Macosx
       class SystemMemory < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private

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

@@ -15,7 +15,6 @@ module Facter
         SP_ETHERNET_DATA_TYPE = %i[type bus vendor_id device_id subsystem_vendor_id
                                    subsystem_id revision_id bsd_name kext_name location version].freeze
 
-        @semaphore = Mutex.new
         @fact_list = {}
 
         class << self

data/lib/facter/resolvers/memory_resolver.rb

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Linux
       class Memory < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
         @log = Facter::Log.new(self)
         class << self
@@ -27,7 +26,7 @@ module Facter
           def read_system(output)
             @fact_list[:total] = kilobytes_to_bytes(output.match(/MemTotal:\s+(\d+)\s/)[1])
             @fact_list[:memfree] = kilobytes_to_bytes(output.match(/MemFree:\s+(\d+)\s/)[1])
-            @fact_list[:used_bytes] = compute_used(@fact_list[:total], @fact_list[:memfree])
+            @fact_list[:used_bytes] = compute_used(@fact_list[:total], reclaimable_memory(output))
             @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total])
           end
 
@@ -45,6 +44,18 @@ module Facter
             quantity.to_i * 1024
           end
 
+          def reclaimable_memory(output)
+            buffers = kilobytes_to_bytes(output.match(/Buffers:\s+(\d+)\s/)[1])
+            cached = kilobytes_to_bytes(output.match(/Cached:\s+(\d+)\s/)[1])
+            s_reclaimable = output.match(/SReclaimable:\s+(\d+)\s/)
+            s_reclaimable = if s_reclaimable
+                              kilobytes_to_bytes(s_reclaimable[1])
+                            else
+                              0
+                            end
+            @fact_list[:memfree] + buffers + cached + s_reclaimable
+          end
+
           def compute_capacity(used, total)
             format('%<computed_capacity>.2f', computed_capacity: (used / total.to_f * 100)) + '%'
           end

data/lib/facter/resolvers/mountpoints_resolver.rb

@@ -2,59 +2,56 @@
 
 module Facter
   module Resolvers
-    module Linux
-      class Mountpoints < BaseResolver
-        include Facter::FilesystemHelper
-        @semaphore = Mutex.new
-        @fact_list ||= {}
-        @log = Facter::Log.new(self)
-        class << self
-          private
-
-          def post_resolve(fact_name)
-            @fact_list.fetch(fact_name) { read_mounts }
-          end
+    class Mountpoints < BaseResolver
+      include Facter::FilesystemHelper
+      @fact_list ||= {}
+      @log = Facter::Log.new(self)
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_mounts }
+        end
 
-          def root_device
-            cmdline = Util::FileHelper.safe_read('/proc/cmdline')
-            match = cmdline.match(/root=([^\s]+)/)
-            match&.captures&.first
-          end
+        def root_device
+          cmdline = Util::FileHelper.safe_read('/proc/cmdline')
+          match = cmdline.match(/root=([^\s]+)/)
+          match&.captures&.first
+        end
 
-          def compute_device(device)
-            # If the "root" device, lookup the actual device from the kernel options
-            # This is done because not all systems symlink /dev/root
-            device = root_device if device == '/dev/root'
-            device
-          end
+        def compute_device(device)
+          # If the "root" device, lookup the actual device from the kernel options
+          # This is done because not all systems symlink /dev/root
+          device = root_device if device == '/dev/root'
+          device
+        end
 
-          def read_mounts # rubocop:disable Metrics/AbcSize
-            mounts = []
-            FilesystemHelper.read_mountpoints.each do |fs|
-              device = compute_device(fs.name)
-              filesystem = fs.mount_type
-              path = fs.mount_point
-              options = fs.options.split(',').map(&:strip)
+        def read_mounts # rubocop:disable Metrics/AbcSize
+          mounts = []
+          FilesystemHelper.read_mountpoints.each do |fs|
+            device = compute_device(fs.name)
+            filesystem = fs.mount_type
+            path = fs.mount_point
+            options = fs.options.split(',').map(&:strip)
 
-              next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
+            next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
 
-              stats = FilesystemHelper.read_mountpoint_stats(path)
-              size_bytes = stats.bytes_total.abs
-              available_bytes = stats.bytes_available.abs
+            stats = FilesystemHelper.read_mountpoint_stats(path)
+            size_bytes = stats.bytes_total.abs
+            available_bytes = stats.bytes_available.abs
 
-              used_bytes = stats.bytes_used.abs
-              total_bytes = used_bytes + available_bytes
-              capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
+            used_bytes = stats.bytes_used.abs
+            total_bytes = used_bytes + available_bytes
+            capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
 
-              size = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
-              available = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes)
-              used = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes)
+            size = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+            available = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes)
+            used = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes)
 
-              mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
-                .map { |v| binding.local_variable_get(v) })]
-            end
-            @fact_list[:mountpoints] = mounts
+            mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
+              .map { |v| binding.local_variable_get(v) })]
           end
+          @fact_list[:mountpoints] = mounts
         end
       end
     end

data/lib/facter/resolvers/networking_linux_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class NetworkingLinux < BaseResolver
-      @semaphore = Mutex.new
       @fact_list = {}
       DIRS = ['/var/lib/dhclient/', '/var/lib/dhcp/', '/var/lib/dhcp3/', '/var/lib/NetworkManager/', '/var/db/'].freeze
 
@@ -11,6 +10,7 @@ module Facter
         private
 
         def post_resolve(fact_name)
+          log.debug('in networking_linux_resolver')
           @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
 
           @fact_list[fact_name]
@@ -36,12 +36,17 @@ module Facter
         end
 
         def retrieve_interface_info
+          log.debug('retrieve_interface_info')
           output = Facter::Core::Execution.execute('ip -o address', logger: log)
+          log.debug("ip -o address result is:\n#{output}")
+
           interfaces = {}
 
           output.each_line do |ip_line|
             ip_tokens = ip_line.split(' ')
 
+            log.debug("ip_tokens = #{ip_tokens}")
+            log.debug("interfaces = #{interfaces}")
             fill_ip_v4_info!(ip_tokens, interfaces)
             fill_io_v6_info!(ip_tokens, interfaces)
             find_dhcp!(ip_tokens, interfaces)
@@ -93,10 +98,15 @@ module Facter
         end
 
         def fill_ip_v4_info!(ip_tokens, network_info)
+          log.debug('fill_ip_v4_info!')
           return unless ip_tokens[2].casecmp('inet').zero?
 
           interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens)
 
+          log.debug("interface_name = #{interface_name}\n" \
+                      "ip4_address = #{ip4_address}\n" \
+                      "ip4_mask_length = #{ip4_mask_length}")
+
           binding = ::Resolvers::Utils::Networking.build_binding(ip4_address, ip4_mask_length)
           build_network_info_structure!(network_info, interface_name, :bindings)
 

data/lib/facter/resolvers/networking_resolver.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Networking < BaseResolver
+      @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)
+          primary_interface
+          interfaces_data
+          ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+          @fact_list[fact_name]
+        end
+
+        def primary_interface
+          result = Facter::Core::Execution.execute('route -n get default', logger: log)
+
+          @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
+        end
+
+        def interfaces_data
+          command_response = Facter::Core::Execution.execute('ifconfig -a', logger: log)
+
+          clean_up_interfaces_response(command_response)
+          parse_interfaces_response(command_response)
+        end
+
+        def clean_up_interfaces_response(response)
+          # convert ip ranges into single ip. eg. 10.16.132.213 -->  10.16.132.213 is converted to 10.16.132.213
+          response.gsub!(/(\d+(\.\d+)*)\s+-->\s+\d+(\.\d+)*/, '\\1')
+        end
+
+        def parse_interfaces_response(response)
+          parsed_interfaces_data = {}
+          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+
+          interfaces_data.each do |interface_name, raw_data|
+            parsed_interface_data = {}
+
+            extract_mtu(raw_data, parsed_interface_data)
+            extract_mac(raw_data, parsed_interface_data)
+            extract_dhcp(interface_name, raw_data, parsed_interface_data)
+            extract_ip_data(raw_data, parsed_interface_data)
+
+            parsed_interfaces_data[interface_name] = parsed_interface_data
+          end
+          @fact_list[:interfaces] = parsed_interfaces_data unless parsed_interfaces_data.empty?
+        end
+
+        def extract_mtu(raw_data, parsed_interface_data)
+          mtu = raw_data.match(/mtu\s+(\d+)/)&.captures&.first&.to_i
+          parsed_interface_data[:mtu] = mtu unless mtu.nil?
+        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
+          parsed_interface_data[:mac] = mac unless mac.nil?
+        end
+
+        def extract_dhcp(interface_name, raw_data, parsed_interface_data)
+          return unless raw_data =~ /status:\s+active/
+
+          result = Facter::Core::Execution.execute("ipconfig getoption #{interface_name} " \
+                                                     'server_identifier', logger: log)
+
+          parsed_interface_data[:dhcp] = result.match(/^[\d.a-f:\s]+$/)&.to_s&.strip unless result.empty?
+        end
+
+        def extract_ip_data(raw_data, parsed_interface_data)
+          ip = extract_values(raw_data, /inet (\S+)/)
+          mask = extract_values(raw_data, /netmask (\S+)/).map { |val| val.hex.to_s(2).count('1') }
+
+          ip6 = extract_values(raw_data, /inet6 (\S+)/).map { |val| val.gsub(/%.+/, '') }
+          mask6 = extract_values(raw_data, /prefixlen (\S+)/)
+
+          parsed_interface_data[:bindings] = create_bindings(ip, mask) unless ip.empty?
+          parsed_interface_data[:bindings6] = create_bindings(ip6, mask6) unless ip6.empty?
+        end
+
+        def extract_values(data, regex)
+          results = []
+          data.scan(regex).flatten.each do |val|
+            results << val
+          end
+          results
+        end
+
+        def create_bindings(ips, masks)
+          bindings = []
+          ips.zip(masks).each do |ip, mask|
+            bindings << ::Resolvers::Utils::Networking.build_binding(ip, mask)
+          end
+          bindings
+        end
+      end
+    end
+  end
+end