facter 4.0.20 → 4.0.21

data/lib/framework/core/fact_loaders/internal_fact_loader.rb

@@ -12,10 +12,10 @@ module Facter
       @facts.select { |fact| fact.type == :legacy }
     end
 
-    def initialize
+    def initialize(os_descendents = nil)
       @facts = []
 
-      os_descendents = OsDetector.instance.hierarchy
+      os_descendents ||= OsDetector.instance.hierarchy
       load_all_oses_in_descending_order(os_descendents)
     end
 

data/lib/framework/core/options/config_file_options.rb

@@ -9,6 +9,16 @@ module Facter
 
         augment_config_path(config_path)
 
+        augment_all
+      end
+
+      def get
+        @options || {}
+      end
+
+      private
+
+      def augment_all
         if Options.cli?
           augment_cli(Facter::ConfigReader.cli)
           augment_ruby(Facter::ConfigReader.global)
@@ -16,15 +26,9 @@ module Facter
         augment_custom(Facter::ConfigReader.global)
         augment_external(Facter::ConfigReader.global)
         augment_show_legacy(Facter::ConfigReader.global)
-        augment_facts(Facter::ConfigReader.ttls)
+        augment_facts(Facter::ConfigReader.ttls, Facter::ConfigReader.fact_groups)
       end
 
-      def get
-        @options || {}
-      end
-
-      private
-
       def augment_config_path(config_path)
         @options[:config] = config_path
       end
@@ -72,11 +76,16 @@ module Facter
         @options[:show_legacy] = global_conf['show-legacy'] unless global_conf['show-legacy'].nil?
       end
 
-      def augment_facts(ttls)
-        blocked_facts = Facter::FactGroups.new.blocked_facts
-        @options[:blocked_facts] = blocked_facts unless blocked_facts.nil?
+      def augment_facts(ttls, groups)
+        fact_groups = Facter::FactGroups.new
 
+        @options[:blocked_facts] = fact_groups.blocked_facts unless fact_groups.blocked_facts.nil?
+        @options[:block_list] = fact_groups.block_list
         @options[:ttls] = ttls unless ttls.nil?
+
+        f_groups = fact_groups.groups || {}
+        f_groups = groups.merge(f_groups) unless groups.nil?
+        @options[:fact_groups] = f_groups
       end
     end
   end

data/lib/framework/core/options/option_store.rb

@@ -21,6 +21,8 @@ module Facter
     @cache = true
     @blocked_facts = []
     @user_query = []
+    @block_list = {}
+    @fact_groups = {}
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy, :trace, :ruby,
@@ -28,7 +30,8 @@ module Facter
 
       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
+                    :config_file_external_dir, :default_external_dir, :fact_groups,
+                    :block_list
 
       attr_writer :external_dir
 
@@ -152,16 +155,22 @@ module Facter
         @log_level = :warn
         @show_legacy = true
         @block = true
+        @ruby = true
+        @user_query = []
+        @cli = nil
+        @cache = true
+        reset_config
+      end
+
+      def reset_config
         @custom_dir = []
         @custom_facts = true
         @external_dir = []
         @default_external_dir = []
         @external_facts = true
-        @ruby = true
         @blocked_facts = []
-        @user_query = []
-        @cli = nil
-        @cache = true
+        @fact_groups = {}
+        @block_list = {}
       end
 
       def fallback_external_dir

data/lib/framework/detector/os_detector.rb

@@ -24,6 +24,8 @@ class OsDetector
                    :macosx
                  when /linux/
                    detect_distro
+                 when /freebsd/
+                   :freebsd
                  when /bsd/
                    :bsd
                  when /solaris/

data/lib/framework/formatters/yaml_fact_formatter.rb

@@ -6,13 +6,59 @@ module Facter
       @log = Log.new(self)
     end
 
-    def format(fact_hash)
-      yaml_pretty = YAML.dump(JSON.parse(JsonFactFormatter.new.format(fact_hash)))
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      facts_to_display = if user_queries.count == 1 && user_queries.first.empty?
+                           FormatterHelper.retrieve_fact_collection(resolved_facts)
+                         else
+                           FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+                         end
+
+      facts_to_display = Psych.parse_stream(facts_to_display.to_yaml)
+      facts_to_display.children[0].tag_directives = []
+      yaml_pretty = quote_special_strings(facts_to_display)
 
-      @log.debug('Replace single backslash with double backslashes')
-      yaml_pretty.gsub!(/\\/, '\&\&')
       @log.debug('Replace ---  from yaml beginning, to keep it compatible with C facter')
       yaml_pretty.gsub(/^---[\r\n]+/, '')
     end
+
+    private
+
+    def quote_special_strings(fact_hash)
+      require 'psych'
+
+      fact_hash.grep(Psych::Nodes::Scalar).each do |node|
+        next unless needs_quote?(node.value)
+
+        node.plain  = false
+        node.quoted = true
+        node.style  = Psych::Nodes::Scalar::DOUBLE_QUOTED
+      end
+
+      fact_hash = unquote_keys(fact_hash)
+      fact_hash.yaml
+    end
+
+    def unquote_keys(fact_hash)
+      fact_hash.grep(Psych::Nodes::Mapping).each do |node|
+        node.children.each_slice(2) do |k, _|
+          k.plain  = true
+          k.quoted = false
+          k.style  = Psych::Nodes::Scalar::ANY
+        end
+      end
+      fact_hash
+    end
+
+    def needs_quote?(value)
+      return false if value =~ /true|false/
+      return false if value[/^[0-9]+$/]
+      return true if value =~ /y|Y|yes|Yes|YES|n|N|no|No|NO|True|TRUE|False|FALSE|on|On|ON|off|Off|OFF|:/
+      return false if value[/[a-zA-Z]/]
+      return false if value[/[0-9]+\.[0-9]+\./]
+
+      true
+    end
   end
 end

data/lib/resolvers/aix/mountpoints.rb

@@ -17,9 +17,9 @@ module Facter
 
           def read_mount(fact_name)
             @fact_list[:mountpoints] = {}
-            output, _status = Open3.capture2('mount 2>/dev/null')
+            output = Facter::Core::Execution.execute('mount', logger: log)
             output.split("\n").map do |line|
-              next if line =~ /\snode\s|---|procfs|ahafs/
+              next if line =~ /node|---|procfs|ahafs/
 
               elem = line.split("\s")
 
@@ -32,7 +32,7 @@ module Facter
           end
 
           def retrieve_sizes_for_mounts
-            output, _status = Open3.capture2('df -P 2>/dev/null')
+            output = Facter::Core::Execution.execute('df -P', logger: log)
             output.split("\n").map do |line|
               next if line =~ /Filesystem|-\s+-\s+-/
 

data/lib/resolvers/aix/networking_resolver.rb

@@ -15,7 +15,7 @@ module Facter
           end
 
           def read_netstat(fact_name)
-            output, _status = Open3.capture2('netstat -rn')
+            output = Facter::Core::Execution.execute('netstat -rn', logger: log)
             output = output.split("\n").select { |line| (line =~ /\s\s[0-9]+.[0-9]+.[0-9]+.[0-9]+|\s\s.*:[0-9a-f]+/) }
             get_primary_interface_info(output)
 

data/lib/resolvers/aix/os_level_resolver.rb

@@ -14,7 +14,7 @@ module Facter
         end
 
         def read_oslevel(fact_name)
-          output, _status = Open3.capture2('/usr/bin/oslevel -s 2>/dev/null')
+          output = Facter::Core::Execution.execute('/usr/bin/oslevel -s', logger: log)
           @fact_list[:build] = output
           @fact_list[:kernel] = 'AIX'
 

data/lib/resolvers/aix/partitions.rb

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Aix
       class Partitions < BaseResolver
-        @log = Facter::Log.new(self)
         @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
@@ -40,11 +39,9 @@ module Facter
           end
 
           def populate_from_lslv(name)
-            stdout, stderr, _status = Open3.capture3("lslv -L #{name}")
-            if stdout.empty?
-              @log.debug(stderr)
-              return
-            end
+            stdout = Facter::Core::Execution.execute("lslv -L #{name}", logger: log)
+
+            return if stdout.empty?
 
             info_hash = extract_info(stdout)
             size_bytes = compute_size(info_hash)

data/lib/resolvers/aix/processors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Processors < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { query_pddv(fact_name) }
+          end
+
+          def query_pddv(fact_name)
+            @fact_list[:models] = []
+            @fact_list[:logical_count] = 0
+
+            odmquery = Facter::ODMQuery.new
+            odmquery.equals('class', 'processor')
+
+            result = odmquery.execute
+
+            return unless result
+
+            proc_names = retrieve_from_array(result.scan(/uniquetype\s=\s.*/), 1)
+
+            proc_names.each { |name| populate_from_cudv(name) }
+
+            @fact_list[fact_name]
+          end
+
+          def populate_from_cudv(name)
+            odmquery = Facter::ODMQuery.new
+            odmquery.equals('PdDvLn', name)
+
+            result = odmquery.execute
+
+            return unless result
+
+            names = retrieve_from_array(result.scan(/name\s=\s.*/), 1)
+
+            names.each { |elem| query_cuat(elem) }
+          end
+
+          def query_cuat(name)
+            odmquery = Facter::ODMQuery.new
+            odmquery.equals('name', name)
+
+            result = odmquery.execute
+
+            return unless result
+
+            type, frequency, smt_threads, smt_enabled = process(result)
+
+            @fact_list[:speed] ||= frequency if frequency
+
+            threads = smt_enabled ? smt_threads : 1
+
+            @fact_list[:logical_count] += threads
+            @fact_list[:models].concat([type] * threads)
+          end
+
+          def process(stdout)
+            type = retrieve_from_array(stdout.scan(/attribute\s=\s"type"\n\s+value\s=\s.*/), 2).first
+            frequency = retrieve_from_array(stdout.scan(/attribute\s=\s"frequency"\n\s+value\s=\s.*/), 2).first
+            smt_threads = retrieve_from_array(stdout.scan(/attribute\s=\s"smt_threads"\n\s+value\s=\s.*/), 2).first
+            smt_enabled = retrieve_from_array(stdout.scan(/attribute\s=\s"smt_enabled"\n\s+value\s=\s.*/), 2).first
+            [type, frequency.to_i, smt_threads.to_i, smt_enabled]
+          end
+
+          def retrieve_from_array(array, pos)
+            array.map { |elem| elem.split('=')[pos].strip.delete('"') }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/utils/odm_query.rb

@@ -12,6 +12,7 @@ module Facter
     def initialize
       @query = ''
       @conditions = []
+      @log = Facter::Log.new(self)
     end
 
     def equals(field, value)
@@ -29,7 +30,7 @@ module Facter
       REPOS.each do |repo|
         break if result && !result.empty?
 
-        result, _stderr, _s = Open3.capture3("#{query} #{repo}")
+        result = Facter::Core::Execution.execute("#{query} #{repo}", logger: @log)
       end
       result
     end

data/lib/resolvers/augeas_resolver.rb

@@ -14,7 +14,7 @@ module Facter
         end
 
         def read_augeas_version(fact_name)
-          output, _status = Open3.capture2('augparse --version 2>&1')
+          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[fact_name]
         end

data/lib/resolvers/eos_release_resolver.rb

@@ -18,7 +18,9 @@ module Facter
         end
 
         def read_eos_release(fact_name)
-          output, _status = Open3.capture2('cat /etc/Eos-release')
+          output = Util::FileHelper.safe_read('/etc/Eos-release', nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
           output_strings = output.split(' ')
 
           @fact_list[:name] = output_strings[0]

data/lib/resolvers/freebsd/freebsd_version_resolver.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class FreebsdVersion < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { freebsd_version_system_call(fact_name) }
+          end
+
+          def freebsd_version_system_call(fact_name)
+            output = Facter::Core::Execution.execute('/bin/freebsd-version -kru', logger: log)
+            return if output.empty?
+
+            build_fact_list(output)
+
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(output)
+            freebsd_version_results = output.split("\n")
+
+            @fact_list[:installed_kernel]   = freebsd_version_results[0].strip
+            @fact_list[:running_kernel]     = freebsd_version_results[1].strip
+            @fact_list[:installed_userland] = freebsd_version_results[2].strip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/hostname_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Hostname < BaseResolver
-      @log = Facter::Log.new(self)
       @semaphore = Mutex.new
       @fact_list ||= {}
       class << self
@@ -14,7 +13,7 @@ module Facter
         end
 
         def retrieve_hostname(fact_name)
-          output, _status = Open3.capture2('hostname')
+          output = Facter::Core::Execution.execute('hostname', logger: log)
 
           # get domain
           domain = read_domain(output)

data/lib/resolvers/lpar_resolver.rb

@@ -14,8 +14,7 @@ module Facter
         end
 
         def read_lpar(fact_name)
-          lpar_cmd = '/usr/bin/lparstat -i'
-          output, _status = Open3.capture2(lpar_cmd)
+          output = Facter::Core::Execution.execute('/usr/bin/lparstat -i', logger: log)
           output.each_line do |line|
             populate_lpar_data(line.split(':').map(&:strip))
           end

data/lib/resolvers/lsb_release_resolver.rb

@@ -10,7 +10,6 @@ module Facter
       # :codename
 
       @semaphore = Mutex.new
-      @log = Facter::Log.new(self)
       @fact_list ||= {}
 
       class << self
@@ -27,14 +26,12 @@ module Facter
         end
 
         def lsb_release_installed?
-          output, stderr, _status = Open3.capture3('which lsb_release')
-          @log.debug(stderr) unless stderr.empty?
+          output = Facter::Core::Execution.execute('which lsb_release', logger: log)
           @fact_list[:lsb_release_installed] = !output.empty?
         end
 
         def read_lsb_release_file
-          output, stderr, _status = Open3.capture3('lsb_release -a')
-          @log.debug(stderr) unless stderr.empty?
+          output = Facter::Core::Execution.execute('lsb_release -a', logger: log)
           build_fact_list(output)
         end