facter 4.0.30 → 4.0.35

data/lib/facter/os_hierarchy.json

@@ -12,7 +12,9 @@
         "Rhel": [
           "Fedora",
           "Amzn",
-          "Centos"
+          "Centos",
+          "Ol",
+          "Scientific"
         ]
       },
       {
@@ -23,14 +25,11 @@
     ]
   },
   {
-    "Solaris": [
-      {
-        "Bsd": [
-          "Freebsd"
-        ]
-      }
+    "Bsd": [
+      "Freebsd"
     ]
   },
+  "Solaris",
   "Macosx",
   "Windows",
   "Aix"

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Disks < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { execute_lspv(fact_name) }
+          end
+
+          def execute_lspv(fact_name)
+            @fact_list[:disks] = {}
+
+            result = Facter::Core::Execution.execute('lspv', logger: log)
+
+            return if result.empty?
+
+            result.each_line do |line|
+              disk_name = line.split(' ')[0].strip
+              size = find_size(disk_name)
+              @fact_list[:disks][disk_name] = size if size
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def find_size(name)
+            stdout = Facter::Core::Execution.execute("lspv #{name}", logger: log)
+
+            return if stdout.empty?
+
+            info_size = InfoExtractor.extract(stdout, /PP SIZE:|TOTAL PPs:|FREE PPs:|PV STATE:/)
+
+            return unless info_size['PV STATE']
+
+            size_bytes = compute_size(info_size)
+
+            {
+              size_bytes: size_bytes,
+              size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+            }
+          end
+
+          def compute_size(size_hash)
+            physical_partitions = size_hash['TOTAL PPs'].to_i + size_hash['FREE PPs'].to_i
+            size_physical_partition = size_hash['PP SIZE']
+            exp = if size_physical_partition[/mega/]
+                    InfoExtractor::MEGABYTES_EXPONENT
+                  else
+                    InfoExtractor::GIGABYTES_EXPONENT
+                  end
+            size_physical_partition.to_i * physical_partitions * exp
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Memory < BaseResolver
+        # :hardware
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { execute_svmon(fact_name) }
+          end
+
+          def execute_svmon(fact_name)
+            result = Facter::Core::Execution.execute('svmon', logger: log)
+            return if result.empty?
+
+            @fact_list[:system] = @fact_list[:swap] = {}
+
+            pagesize = call_pagesize.to_i
+            return if pagesize.zero?
+
+            result.each_line do |line|
+              @fact_list[:system] = populate_system(line, pagesize) if line.include?('memory')
+              @fact_list[:swap] = populate_swap(line, pagesize) if line =~ /pg\sspace/
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def call_pagesize
+            Facter::Core::Execution.execute('pagesize', logger: log).strip
+          end
+
+          def populate_system(content, pagesize)
+            content = content.split(' ')
+
+            total = content[1].to_i * pagesize
+            used = content[2].to_i * pagesize
+
+            { available_bytes: content[3].to_i * pagesize,
+              total_bytes: total,
+              used_bytes: used,
+              capacity: FilesystemHelper.compute_capacity(used, total) }
+          end
+
+          def populate_swap(content, pagesize)
+            content = content.split(' ')
+
+            total = content[2].to_i * pagesize
+            used = content[3].to_i * pagesize
+
+            { available_bytes: total - used,
+              total_bytes: total,
+              used_bytes: used,
+              capacity: FilesystemHelper.compute_capacity(used, total) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,9 +9,6 @@ module Facter
         class << self
           private
 
-          MEGABYTES_EXPONENT = 1024**2
-          GIGABYTES_EXPONENT = 1024**3
-
           def post_resolve(fact_name)
             @fact_list.fetch(fact_name) { query_cudv(fact_name) }
           end
@@ -43,7 +40,7 @@ module Facter
 
             return if stdout.empty?
 
-            info_hash = extract_info(stdout)
+            info_hash =  InfoExtractor.extract(stdout, /PPs:|PP SIZE|TYPE:|LABEL:|MOUNT/)
             size_bytes = compute_size(info_hash)
 
             part_info = {
@@ -51,29 +48,21 @@ module Facter
               size_bytes: size_bytes,
               size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
             }
-            mount = info_hash['MOUNTPOINT']
+            mount = info_hash['MOUNT POINT']
             label = info_hash['LABEL']
             part_info[:mount] = mount unless %r{N/A} =~ mount
-            part_info[:label] = label unless /None/ =~ label
+            part_info[:label] = label.strip unless /None/ =~ label
             part_info
           end
 
-          def extract_info(lsl_content)
-            lsl_content = lsl_content.strip.split("\n").map do |line|
-              next unless /PPs:|PP SIZE|TYPE:|LABEL:|MOUNT/ =~ line
-
-              line.split(/:|\s\s/).reject(&:empty?)
-            end
-
-            lsl_content.flatten!.select! { |elem| elem }.map! { |elem| elem.delete("\s") }
-
-            Hash[*lsl_content]
-          end
-
           def compute_size(info_hash)
             physical_partitions = info_hash['PPs'].to_i
-            size_physical_partition = info_hash['PPSIZE']
-            exp = size_physical_partition[/mega/] ? MEGABYTES_EXPONENT : GIGABYTES_EXPONENT
+            size_physical_partition = info_hash['PP SIZE']
+            exp = if size_physical_partition[/mega/]
+                    InfoExtractor::MEGABYTES_EXPONENT
+                  else
+                    InfoExtractor::GIGABYTES_EXPONENT
+                  end
             size_physical_partition.to_i * physical_partitions * exp
           end
         end

data/lib/facter/resolvers/aix/utils/info_extractor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facter
+  module InfoExtractor
+    MEGABYTES_EXPONENT = 1024**2
+    GIGABYTES_EXPONENT = 1024**3
+
+    def self.extract(content, regex)
+      content = content.each_line.map do |line|
+        next unless regex =~ line
+
+        line.split(/:\s*|\s{2,}/)
+      end
+
+      content.flatten!.reject!(&:nil?)
+
+      Hash[*content]
+    end
+  end
+end

data/lib/facter/resolvers/augeas_resolver.rb

@@ -14,10 +14,27 @@ module Facter
         end
 
         def read_augeas_version(fact_name)
-          output = Facter::Core::Execution.execute('augparse --version 2>&1', logger: log)
-          @fact_list[:augeas_version] = Regexp.last_match(1) if output =~ /^augparse (\d+\.\d+\.\d+)/
+          @fact_list[:augeas_version] = read_augeas_from_cli
+          @fact_list[:augeas_version] ||= read_augeas_from_gem
+
           @fact_list[fact_name]
         end
+
+        def read_augeas_from_cli
+          output = Facter::Core::Execution.execute('augparse --version 2>&1', logger: log)
+          Regexp.last_match(1) if output =~ /^augparse (\d+\.\d+\.\d+)/
+        end
+
+        def read_augeas_from_gem
+          require 'augeas'
+
+          if Gem.loaded_specs['augeas']
+            ::Augeas.create { |aug| aug.get('/augeas/version') }
+          else
+            # it is used for legacy augeas <= 0.5.0 (ruby-augeas gem)
+            ::Augeas.open { |aug| aug.get('/augeas/version') }
+          end
+        end
       end
     end
   end

data/lib/facter/resolvers/base_resolver.rb

@@ -20,7 +20,7 @@ module Facter
           subscribe_to_manager
           post_resolve(fact_name)
         end
-      rescue LoadError => e
+      rescue LoadError, NameError => e
         log.debug("resolving fact #{fact_name}, but #{e}")
         @fact_list[fact_name] = nil
       end

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

@@ -9,19 +9,9 @@ module Facter
         extend FFI::Library
 
         ffi_lib 'c'
-        attach_function :getloadavg, %i[pointer int], :int
         attach_function :sysctl, %i[pointer uint pointer pointer pointer size_t], :int
       end
 
-      def self.read_load_averages
-        raw_loadavg = FFI::MemoryPointer.new(:double, 3)
-
-        res = Libc.getloadavg(raw_loadavg, 3)
-        return unless res == 3
-
-        raw_loadavg.read_array_of_double(res)
-      end
-
       def self.sysctl(type, oids)
         name = FFI::MemoryPointer.new(:uint, oids.size)
         name.write_array_of_uint(oids)

data/lib/facter/resolvers/ec2.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'net/http'
-
 module Facter
   module Resolvers
     class Ec2 < BaseResolver
@@ -52,6 +50,8 @@ module Facter
         end
 
         def get_data_from(url)
+          require 'net/http'
+
           parsed_url = URI.parse(url)
           http = Net::HTTP.new(parsed_url.host)
           http.read_timeout = determine_session_timeout

data/lib/facter/resolvers/filesystems_resolver.rb

@@ -22,7 +22,7 @@ module Facter
             filesystems = []
             output.each do |line|
               tokens = line.split(' ')
-              filesystems << tokens if tokens.size == 1
+              filesystems << tokens if tokens.size == 1 && tokens.first != 'fuseblk'
             end
             @fact_list[:systems] = filesystems.sort.join(',')
             @fact_list[fact_name]

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class DmiBios < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          #:model
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+
+            @fact_list[:bios_date]    = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.bios.reldate')
+            @fact_list[:bios_vendor]  = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.bios.vendor')
+            @fact_list[:bios_version] = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.bios.version')
+
+            @fact_list[:product_name]   = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.product')
+            @fact_list[:product_serial] = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.serial')
+            @fact_list[:product_uuid]   = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.uuid')
+
+            @fact_list[:sys_vendor] = Facter::Freebsd::FfiHelper.kenv(:get, 'smbios.system.maker')
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,10 +8,29 @@ module Facter
       module Libc
         extend FFI::Library
 
+        KENV_GET = 0
+
+        KENV_MVALLEN = 128
+
         ffi_lib 'c'
+        attach_function :kenv, %i[int string pointer int], :int
         attach_function :sysctlbyname, %i[string pointer pointer pointer size_t], :int
       end
 
+      def self.kenv(action, name, value = nil)
+        case action
+        when :get
+          len = Libc::KENV_MVALLEN + 1
+          value = FFI::MemoryPointer.new(:char, len)
+          res = Libc.kenv(Libc::KENV_GET, name, value, len)
+          return nil if res.negative?
+
+          value.read_string(res).chomp("\0")
+        else
+          raise "Action #{action} not supported"
+        end
+      end
+
       def self.sysctl_by_name(type, name)
         oldp = FFI::Pointer::NULL
         oldlenp = FFI::MemoryPointer.new(:size_t)

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      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('swapinfo -k', logger: log)
+            data = output.split("\n")[1..-1].map { |line| line.split(/\s+/) }
+
+            unless data.empty?
+              @fact_list[:total_bytes]     = kilobytes_to_bytes(data.map { |line| line[1].to_i }.inject(:+))
+              @fact_list[:used_bytes]      = kilobytes_to_bytes(data.map { |line| line[2].to_i }.inject(:+))
+              @fact_list[:available_bytes] = kilobytes_to_bytes(data.map { |line| line[3].to_i }.inject(:+))
+              @fact_list[:capacity] = FilesystemHelper.compute_capacity(@fact_list[:used_bytes],
+                                                                        @fact_list[:total_bytes])
+              @fact_list[:encrypted] = data.map { |line| line[0].end_with?('.eli') }.all?
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def kilobytes_to_bytes(quantity)
+            (quantity.to_f * 1024).to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      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] = FilesystemHelper.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('vmstat -H --libxo json', logger: log)
+            data = JSON.parse(output)
+            @fact_list[:available_bytes] = data['memory']['free-memory'] * 1024
+          end
+
+          def read_total_memory_in_bytes
+            require_relative 'ffi/ffi_helper'
+
+            @fact_list[:total_bytes] = Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'hw.physmem')
+          end
+        end
+      end
+    end
+  end
+end