facter 4.0.23

data/lib/resolvers/macosx/dmi_resolver.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class DmiBios < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          #:model
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts }
+          end
+
+          def read_facts
+            # OSX only supports the product name
+            output = Facter::Core::Execution.execute('sysctl -n hw.model', logger: log)
+            @fact_list[:macosx_model] = output&.strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/filesystems_resolver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class Filesystems < BaseResolver
+        # :macosx_filesystems
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_filesystems(fact_name) }
+          end
+
+          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
+            @fact_list[:macosx_filesystems] = filesystems.uniq.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/ipaddress_resolver.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class Ipaddress < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_ipaddress(fact_name) }
+          end
+
+          def read_ipaddress(fact_name)
+            ip = nil
+            primary_interface = read_primary_interface
+            unless primary_interface.nil?
+              @fact_list[:primary] = primary_interface
+              output = Facter::Core::Execution.execute("ipconfig getifaddr #{primary_interface}", logger: log)
+              ip = output.strip
+            end
+            find_all_interfaces
+            @fact_list[:ip] = ip
+            @fact_list[fact_name]
+          end
+
+          def read_primary_interface
+            iface = nil
+            output = Facter::Core::Execution.execute('route -n get default', logger: log)
+            output.split(/^\S/).each do |str|
+              iface = Regexp.last_match(1) if str.strip =~ /interface: (\S+)/
+            end
+            iface
+          end
+
+          def find_all_interfaces
+            output = Facter::Core::Execution.execute('ifconfig -a', logger: log)
+
+            data_hash = Hash[*output.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+
+            macaddress = */ether (([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2}))/.match(data_hash[@fact_list[:primary]])
+            @fact_list[:macaddress] = macaddress[1]
+
+            @fact_list[:interfaces] = data_hash.keys.join(',')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/load_averages_resolver.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class LoadAverages < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_load_averages_file(fact_name) }
+          end
+
+          def read_load_averages_file(fact_name)
+            output = Facter::Core::Execution.execute('sysctl -n vm.loadavg', logger: log)
+            @fact_list[:load_averages] = {}.tap { |h| _, h['1m'], h['5m'], h['15m'], = output.split.map(&:to_f) }
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/mountpoints_resolver.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class Mountpoints < BaseResolver
+        include Facter::FilesystemHelper
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_mounts }
+          end
+
+          def read_mounts # rubocop:disable Metrics/AbcSize
+            mounts = {}
+            FilesystemHelper.read_mountpoints.each do |fs|
+              device = fs.name
+              filesystem = fs.mount_type
+              path = fs.mount_point
+              options = fs.options.split(',').map(&:strip).map { |o| o == 'rootfs' ? 'root' : o }
+
+              next if path =~ %r{^/(proc|sys)} && filesystem != 'tmpfs' || filesystem == 'autofs'
+
+              mounts[path] = read_stats(path).tap do |hash|
+                hash[:device] = device
+                hash[:filesystem] = filesystem
+                hash[:options] = options if options.any?
+              end
+            end
+
+            @fact_list[:mountpoints] = mounts
+          end
+
+          def read_stats(path)
+            begin
+              stats = FilesystemHelper.read_mountpoint_stats(path)
+              size_bytes = stats.bytes_total
+              used_bytes = stats.bytes_used
+              available_bytes = size_bytes - used_bytes
+            rescue Sys::Filesystem::Error
+              size_bytes = used_bytes = available_bytes = 0
+            end
+
+            {
+              size_bytes: size_bytes,
+              used_bytes: used_bytes,
+              available_bytes: available_bytes,
+              capacity: FilesystemHelper.compute_capacity(used_bytes, size_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)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/processor_resolver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+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',
+                  brand: 'machdep.cpu.brand_string',
+                  speed: 'hw.cpufrequency_max' }.freeze
+        class << self
+          # :logicalcount
+          # :models
+          # :physicalcount
+          # :speed
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_processor_data(fact_name) }
+          end
+
+          def read_processor_data(fact_name)
+            output = Facter::Core::Execution.execute("sysctl #{ITEMS.values.join(' ')}", logger: log)
+            build_fact_list(output.split("\n"))
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(processors_data)
+            build_logical_count(processors_data[0])
+            build_physical_count(processors_data[1])
+            build_models(processors_data[2])
+            build_speed(processors_data[3])
+          end
+
+          def build_logical_count(count)
+            @fact_list[:logicalcount] = count.split(': ')[1].to_i
+          end
+
+          def build_physical_count(count)
+            @fact_list[:physicalcount] = count.split(': ')[1].to_i
+          end
+
+          def build_models(model)
+            brand = model.split(': ').fetch(1)
+            @fact_list[:models] = Array.new(@fact_list[:logicalcount].to_i, brand)
+          end
+
+          def build_speed(value)
+            @fact_list[:speed] = value.split(': ')[1].to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/swap_memory_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class SwapMemory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_swap_memory(fact_name) }
+          end
+
+          def read_swap_memory(fact_name) # rubocop:disable Metrics/AbcSize
+            output = Facter::Core::Execution.execute('sysctl -n vm.swapusage', logger: log)
+            data = output.match(/^total = ([\d.]+)M  used = ([\d.]+)M  free = ([\d.]+)M  (\(encrypted\))$/)
+
+            if data[1].to_f.positive?
+              @fact_list[:total_bytes] = megabytes_to_bytes(data[1])
+              @fact_list[:used_bytes] = megabytes_to_bytes(data[2])
+              @fact_list[:available_bytes] = megabytes_to_bytes(data[3])
+              @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
+              @fact_list[:encrypted] = data[4] == '(encrypted)'
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def megabytes_to_bytes(quantity)
+            (quantity.to_f * 1_048_576).to_i
+          end
+
+          def compute_capacity(used, total)
+            "#{format('%<value>.2f', value: (used / total.to_f * 100))}%"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/system_memory_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class SystemMemory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { calculate_system_memory(fact_name) }
+          end
+
+          def calculate_system_memory(fact_name)
+            read_total_memory_in_bytes
+            read_available_memory_in_bytes
+
+            @fact_list[:used_bytes] = @fact_list[:total_bytes] - @fact_list[:available_bytes]
+            @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
+
+            @fact_list[fact_name]
+          end
+
+          def read_available_memory_in_bytes
+            output = Facter::Core::Execution.execute('vm_stat', logger: log)
+            page_size = output.match(/page size of (\d+) bytes/)[1].to_i
+            pages_free = output.match(/Pages free:\s+(\d+)/)[1].to_i
+
+            @fact_list[:available_bytes] = page_size * pages_free
+          end
+
+          def read_total_memory_in_bytes
+            @fact_list[:total_bytes] = Facter::Core::Execution.execute('sysctl -n hw.memsize', logger: log).to_i
+          end
+
+          def compute_capacity(used, total)
+            "#{format('%<value>.2f', value: (used / total.to_f * 100))}%"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/system_profiler_resolver.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SystemProfiler < BaseResolver
+      # model_name
+      # model_identifier
+      # processor_name
+      # processor_speed
+      # number_of_processors
+      # total_number_of_cores
+      # l2_cache_per_core
+      # l3_cache
+      # hyper-threading_technology
+      # memory
+      # boot_rom_version
+      # serial_number_system
+      # hardware_uuid
+      # activation_lock_status
+      # system_version
+      # kernel_version
+      # boot_volume
+      # boot_mode
+      # computer_name
+      # user_name
+      # secure_virtual_memory
+      # system_integrity_protection
+      # time_since_boot
+      # smc_version_system
+
+      @semaphore = Mutex.new
+      @fact_list = {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_system_profiler(fact_name) }
+        end
+
+        def retrieve_system_profiler(fact_name)
+          @fact_list ||= {}
+
+          log.debug 'Executing command: system_profiler SPSoftwareDataType SPHardwareDataType'
+          output = Facter::Core::Execution.execute(
+            'system_profiler SPHardwareDataType SPSoftwareDataType', logger: log
+          )
+          @fact_list = output.scan(/.*:[ ].*$/).map { |e| e.strip.match(/(.*?): (.*)/).captures }.to_h
+          normalize_factlist
+
+          @fact_list[fact_name]
+        end
+
+        def normalize_factlist
+          @fact_list = @fact_list.map do |k, v|
+            [k.downcase.tr(' ', '_').delete("\(\)").to_sym, v]
+          end.to_h
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/memory_resolver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Memory < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        @log = Facter::Log.new(self)
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_meminfo_file(fact_name) }
+          end
+
+          def read_meminfo_file(fact_name)
+            meminfo_output = Util::FileHelper.safe_read('/proc/meminfo', nil)
+            return unless meminfo_output
+
+            read_system(meminfo_output)
+            read_swap(meminfo_output)
+
+            @fact_list[fact_name]
+          end
+
+          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[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total])
+          end
+
+          def read_swap(output)
+            total = output.match(/SwapTotal:\s+(\d+)\s/)[1]
+            return if total.to_i.zero?
+
+            @fact_list[:swap_total] = kilobytes_to_bytes(total)
+            @fact_list[:swap_free] = kilobytes_to_bytes(output.match(/SwapFree:\s+(\d+)\s/)[1])
+            @fact_list[:swap_used_bytes] = compute_used(@fact_list[:swap_total], @fact_list[:swap_free])
+            @fact_list[:swap_capacity] = compute_capacity(@fact_list[:swap_used_bytes], @fact_list[:swap_total])
+          end
+
+          def kilobytes_to_bytes(quantity)
+            quantity.to_i * 1024
+          end
+
+          def compute_capacity(used, total)
+            format('%<computed_capacity>.2f', computed_capacity: (used / total.to_f * 100)) + '%'
+          end
+
+          def compute_used(total, free)
+            total - free
+          end
+        end
+      end
+    end
+  end
+end