facter 4.0.31 → 4.0.36

data/lib/facter/resolvers/gce.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Gce < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      METADATA_URL = 'http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=json'
+      HEADERS = { "Metadata-Flavor": 'Google', "Accept": 'application/json' }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          log.debug('reading Gce metadata')
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = query_for_metadata
+          @fact_list[fact_name]
+        end
+
+        def query_for_metadata
+          gce_data = extract_to_hash(Utils::Http.get_request(METADATA_URL, HEADERS))
+          parse_instance(gce_data)
+
+          gce_data.empty? ? nil : gce_data
+        end
+
+        def extract_to_hash(metadata)
+          JSON.parse(metadata)
+        rescue JSON::ParserError => e
+          log.debug("Trying to parse result but got: #{e.message}")
+          {}
+        end
+
+        def parse_instance(gce_data)
+          instance_data = gce_data['instance']
+          return if instance_data.nil? || instance_data.empty?
+
+          %w[image machineType zone].each do |key|
+            instance_data[key] = instance_data[key].split('/').last if instance_data[key]
+          end
+
+          network = instance_data.dig('networkInterfaces', 0, 'network')
+          instance_data['networkInterfaces'][0]['network'] = network.split('/').last unless network.nil?
+
+          gce_data['instance'] = instance_data
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class DockerUptime < BaseResolver
+        @semaphore = Mutex.new
+        @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,7 +4,6 @@ module Facter
   module Resolvers
     module Linux
       class LoadAverages < BaseResolver
-        @log = Facter::Log.new(self)
         @semaphore = Mutex.new
         @fact_list ||= {}
         class << self

data/lib/facter/resolvers/load_averages.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class LoadAverages < BaseResolver
+      @semaphore = Mutex.new
+      @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/lspci.rb

@@ -28,6 +28,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/memory_resolver.rb

@@ -27,7 +27,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 +45,13 @@ 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 = kilobytes_to_bytes(output.match(/SReclaimable:\s+(\d+)\s/)[1])
+            @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,57 @@
 
 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
+      @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
 
-          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

@@ -11,6 +11,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 +37,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)
@@ -85,14 +91,23 @@ module Facter
           return unless lease_file
 
           dhcp = Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
-          dhcp ? dhcp.match(/SERVER_ADDRESS=(.*)/)[1] : nil
+
+          return unless dhcp
+
+          dhcp = dhcp.match(/SERVER_ADDRESS=(.*)/)
+          dhcp[1] if dhcp
         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,106 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Networking < 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)
+          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

data/lib/facter/resolvers/os_release_resolver.rb

@@ -56,7 +56,7 @@ module Facter
         def process_name
           return unless @fact_list[:name]
 
-          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red')
+          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red', 'oracle')
                                 @fact_list[:name].split(' ')[0..1].join
                               else
                                 @fact_list[:name].split(' ')[0].strip

data/lib/facter/resolvers/processors_resolver.rb

@@ -7,10 +7,12 @@ module Facter
         @log = Facter::Log.new(self)
         @semaphore = Mutex.new
         @fact_list ||= {}
+        MHZ_TO_HZ = 1_000_000
         class << self
           # :count
           # :models
           # :physical_count
+          # :speed
 
           private
 
@@ -38,6 +40,7 @@ module Facter
               count_processors(tokens)
               construct_models_list(tokens)
               count_physical_processors(tokens)
+              build_speed(tokens)
             end
           end
 
@@ -46,7 +49,9 @@ module Facter
           end
 
           def construct_models_list(tokens)
-            @fact_list[:models] << tokens.last.strip if tokens.first.strip == 'model name'
+            return unless tokens.first.strip == 'model name' || tokens.first.strip == 'cpu'
+
+            @fact_list[:models] << tokens.last.strip
           end
 
           def count_physical_processors(tokens)
@@ -54,7 +59,24 @@ module Facter
           end
 
           def physical_devices_count
-            Dir.entries('/sys/devices/system/cpu').count { |dir| dir =~ /cpu[0-9]+$/ }
+            Dir.entries('/sys/devices/system/cpu')
+               .select { |dir| dir =~ /cpu[0-9]+$/ }
+               .count { |dir| File.exist?("/sys/devices/system/cpu/#{dir}/topology/physical_package_id") }
+          end
+
+          def build_speed(tokens)
+            build_speed_for_power_pc(tokens) if tokens.first.strip == 'clock'
+            build_speed_for_x86(tokens) if tokens.first.strip == 'cpu MHz'
+          end
+
+          def build_speed_for_power_pc(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*MHz/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
+          end
+
+          def build_speed_for_x86(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
           end
         end
       end