facter 4.0.29 → 4.0.34

data/{os_hierarchy.json → lib/facter/os_hierarchy.json}

@@ -12,7 +12,9 @@
         "Rhel": [
           "Fedora",
           "Amzn",
-          "Centos"
+          "Centos",
+          "Ol",
+          "Scientific"
         ]
       },
       {

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/{resolvers → 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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Augeas < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_augeas_version(fact_name) }
+        end
+
+        def read_augeas_version(fact_name)
+          @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
+end

data/lib/{resolvers → 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/{resolvers → facter/resolvers}/bsd/processors.rb

@@ -15,7 +15,7 @@ module Facter
           end
 
           def collect_processors_info(fact_name)
-            require "#{ROOT_DIR}/lib/resolvers/bsd/ffi/ffi_helper"
+            require 'facter/resolvers/bsd/ffi/ffi_helper'
 
             @fact_list[:logical_count] = logical_count
             @fact_list[:models] = Array.new(logical_count, model) if logical_count && model

data/lib/{resolvers/docker_lxc.rb → facter/resolvers/containers.rb}

@@ -2,7 +2,7 @@
 
 module Facter
   module Resolvers
-    class DockerLxc < BaseResolver
+    class Containers < BaseResolver
       # :virtual
       # :hypervisor
 
@@ -20,13 +20,14 @@ module Facter
         def read_cgroup(fact_name)
           output_cgroup = Util::FileHelper.safe_read('/proc/1/cgroup', nil)
           output_environ = Util::FileHelper.safe_read('/proc/1/environ', nil)
-          return if output_cgroup.nil? || output_environ.nil?
+          return unless output_cgroup && output_environ
 
           output_docker = %r{docker/(.+)}.match(output_cgroup)
           output_lxc = %r{^/lxc/([^/]+)}.match(output_cgroup)
           lxc_from_environ = /container=lxc/ =~ output_environ
 
           info, vm = extract_vm_and_info(output_docker, output_lxc, lxc_from_environ)
+          info, vm = extract_for_nspawn(output_environ) unless vm
           @fact_list[:vm] = vm
           @fact_list[:hypervisor] = { vm.to_sym => info } if vm
           @fact_list[fact_name]
@@ -43,6 +44,15 @@ module Facter
 
           [info ? { INFO[vm] => info } : {}, vm]
         end
+
+        def extract_for_nspawn(output_environ)
+          nspawn = /container=systemd-nspawn/ =~ output_environ
+          if nspawn
+            vm = 'systemd_nspawn'
+            info = Util::FileHelper.safe_read('/etc/machine-id', nil)
+          end
+          [info ? { 'id' => info.strip } : {}, vm]
+        end
       end
     end
   end

data/lib/facter/resolvers/dmi_decode.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DmiDecode < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      ADDRESS_TO_VERSION = {
+        0xe8480 => 'ESXi 2.5',
+        0xe7c70 => 'ESXi 3.0',
+        0xe66c0 => 'ESXi 3.5',
+        0xe7910 => 'ESXi 3.5',
+        0xea550 => 'ESXi 4.0',
+        0xea6c0 => 'ESXi 4.0',
+        0xea2e0 => 'ESXi 4.1',
+        0xe72c0 => 'ESXi 5.0',
+        0xea0c0 => 'ESXi 5.1',
+        0xea050 => 'ESXi 5.5',
+        0xe99e0 => 'ESXi 6.0',
+        0xE9A40 => 'ESXi 6.0',
+        0xea580 => 'ESXi 6.5',
+        0xEA520 => 'ESXi 6.7',
+        0xEA490 => 'ESXi 6.7',
+        0xea5e0 => 'Fusion 8.5'
+      }.freeze
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { run_dmidecode(fact_name) }
+        end
+
+        def run_dmidecode(fact_name)
+          output = Facter::Core::Execution.execute('dmidecode', logger: log)
+
+          @fact_list[:virtualbox_version] = output.match(/vboxVer_(\S+)/)&.captures&.first
+          @fact_list[:virtualbox_revision] = output.match(/vboxRev_(\S+)/)&.captures&.first
+          @fact_list[:vmware_version] = extract_vmware_version(output)
+
+          @fact_list[fact_name]
+        end
+
+        def extract_vmware_version(output)
+          address_of_version = output.match(/Address:\s(0x[a-zA-Z0-9]*)/)&.captures&.first
+
+          ADDRESS_TO_VERSION[address_of_version&.hex]
+        end
+      end
+    end
+  end
+end

data/lib/{resolvers → facter/resolvers}/facterversion_resolver.rb

@@ -14,8 +14,7 @@ module Facter
         end
 
         def read_version_file
-          version_file = ::File.join(ROOT_DIR, 'VERSION')
-          @fact_list[:facterversion] = ::File.read(version_file).chomp('')
+          @fact_list[:facterversion] = Facter::VERSION
         end
       end
     end