facter 4.0.28 → 4.0.33

data/lib/{framework → facter/framework}/core/options.rb

@@ -45,6 +45,7 @@ module Facter
         Facter::OptionStore.cli = true
         Facter::OptionStore.show_legacy = false
         Facter::OptionStore.user_query = user_query
+        Facter::OptionStore.trace = cli_options[:trace]
         OptionStore.set(:config, cli_options[:config])
         ConfigFileOptions.init(cli_options[:config])
         store(ConfigFileOptions.get)

data/lib/{framework → facter/framework}/core/options/option_store.rb

@@ -25,13 +25,13 @@ module Facter
     @color = false
 
     class << self
-      attr_reader :debug, :verbose, :log_level, :show_legacy, :trace, :ruby,
+      attr_reader :debug, :verbose, :log_level, :show_legacy, :ruby,
                   :custom_facts, :blocked_facts
 
       attr_accessor :config, :user_query, :strict, :json, :haml, :external_facts,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
                     :config_file_external_dir, :default_external_dir, :fact_groups,
-                    :block_list, :color
+                    :block_list, :color, :trace
 
       attr_writer :external_dir
 
@@ -131,10 +131,6 @@ module Facter
         end
       end
 
-      def trace=(bool)
-        Facter.trace(bool)
-      end
-
       def set(key, value)
         send("#{key}=".to_sym, value)
       end
@@ -150,6 +146,7 @@ module Facter
         @user_query = []
         @cli = nil
         @cache = true
+        @trace = false
         reset_config
       end
 

data/lib/{framework → facter/framework}/detector/os_hierarchy.rb

@@ -4,8 +4,8 @@ module Facter
   class OsHierarchy
     def initialize
       @log = Log.new(self)
-      json_file = Util::FileHelper.safe_read(File.join(ROOT_DIR, 'os_hierarchy.json'))
-
+      json_file_path = File.join(File.dirname(__FILE__), '../../os_hierarchy.json')
+      json_file = Util::FileHelper.safe_read(json_file_path)
       begin
         @json_os_hierarchy = JSON.parse(json_file)
       rescue JSON::ParserError => _e

data/lib/{framework → facter/framework}/logging/logger.rb

@@ -3,10 +3,11 @@
 require 'logger'
 
 module Facter
-  RED = 31
-  GREEN = 32
-  YELLOW = 33
-  CYAN = 36
+  RED     = "\e[31m"
+  GREEN   = "\e[32m"
+  YELLOW  = "\e[33m"
+  CYAN    = "\e[36m"
+  RESET   = "\e[0m"
 
   DEFAULT_LOG_LEVEL = :warn
 
@@ -104,12 +105,19 @@ module Facter
       end
     end
 
+    def log_exception(exception)
+      msg = colorize(exception.message, RED) + "\n"
+      msg += exception.backtrace.join("\n") if Options[:trace]
+
+      @@logger.error(@class_name + ' - ' + msg)
+    end
+
     private
 
     def colorize(msg, color)
       return msg if OsDetector.instance.identifier.eql?(:windows)
 
-      "\e[0;#{color}m#{msg}\e[0m"
+      "#{color}#{msg}#{RESET}"
     end
 
     def debugging_active?

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/networking_resolver.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Networking < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_netstat(fact_name) }
+          end
+
+          def read_netstat(fact_name)
+            @fact_list[:interfaces] = {}
+            output = Facter::Core::Execution.execute('netstat -rn', logger: log)
+            output = output.each_line.select { |line| (line =~ /\s\s[0-9]+.[0-9]+.[0-9]+.[0-9]+|\s\s.*:[0-9a-f]+/) }
+            extract_interfaces(output)
+
+            populate_with_mtu_and_mac!(@fact_list[:interfaces])
+            get_primary_interface_info(output)
+            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+            @fact_list[fact_name]
+          end
+
+          def get_primary_interface_info(output)
+            primary_interface_info = output.find { |line| line =~ /=>/ }&.split(' ')
+            @fact_list[:primary_interface] = primary_interface_info[5] if primary_interface_info
+          end
+
+          def extract_interfaces(netstat_output)
+            netstat_output.each do |line|
+              next if line =~ /default/
+
+              info = line.split("\s")
+              mask_length = info[0].match(%r{/([0-9]+)|%([0-9]+)})
+              next unless mask_length
+
+              is_ipv4 = info[1] =~ /[0-9]+.[0-9]+.[0-9]+.[0-9]+/
+              build_bindings(info[5], info[1], mask_length[1] || mask_length[2], is_ipv4)
+            end
+          end
+
+          def build_bindings(name, ip, mask_length, is_ipv4)
+            bind_to_add = is_ipv4 ? :bindings : :bindings6
+            ip = ip.gsub(/%[0-9]$/, '') # remove mask information if it exists
+            mask_length = mask_length.to_i - 1 unless is_ipv4
+            @fact_list[:interfaces][name] ||= {}
+            @fact_list[:interfaces][name][bind_to_add] ||= []
+            @fact_list[:interfaces][name][bind_to_add] << ::Resolvers::Utils::Networking.build_binding(ip, mask_length)
+          end
+
+          def populate_with_mtu_and_mac!(interfaces)
+            output = Facter::Core::Execution.execute('netstat -in', logger: log)
+            output.each_line do |line|
+              next if line =~ /Name\s/
+
+              info = line.split("\s")
+              interface_name = info[0]
+              mac = info[3][/^([0-9a-f]{1,2}[\.:-]){5}([0-9a-f]{1,2})$/]
+              interfaces[interface_name][:mtu] = info[1].to_i
+              interfaces[interface_name][:mac] = format_mac_address(mac) if mac
+            end
+          end
+
+          def format_mac_address(address)
+            address.split('.').map { |e| format('%<mac_address>02s', mac_address: e) }.join(':').tr(' ', '0')
+          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