facter 3.12.2.cfacter.20181217 → 4.0.7.pre

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  module DefaultOptions
+    def augment_with_defaults!
+      cli_defaults
+      global_defaults
+    end
+
+    def augment_with_to_hash_defaults!
+      @options[:show_legacy] = true
+    end
+
+    private
+
+    def cli_defaults
+      @options[:debug] ||= false
+      @options[:trace] ||= false
+      @options[:verbose] ||= false
+      @options[:log_level] ||= :warn
+      @options[:show_legacy] ||= false
+    end
+
+    def global_defaults
+      @options[:custom_facts] ||= true
+      @options[:custom_dir] ||= []
+      @options[:external_facts] ||= true
+      @options[:external_dir] ||= []
+      @options[:ruby] ||= true
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Facter
+  module HelperOptions
+    def augment_with_helper_options!(user_query)
+      @options[:user_query] = true if user_query.any?
+
+      if @options[:ruby] == false
+        @options[:custom_facts] = false
+        @options[:blocked_facts] = ['ruby'].concat(@options[:blocked_facts] || [])
+      end
+
+      # convert array or string to array
+      @options[:external_dir] = [*@options[:external_dir]] unless @options[:external_dir].nil?
+
+      @options[:log_level] = log_level || @options[:log_level]
+      validate_log_level
+      LegacyFacter.trace(@options[:trace])
+    end
+
+    private
+
+    def log_level
+      :debug if @options[:debug] || @options[:log_level] == :trace
+    end
+
+    def validate_log_level
+      if @options[:log_level].empty?
+        OptionsValidator.write_error_and_exit('the required argument for option'\
+                                                            " '--log-level' is missing")
+      end
+      unless OptionsValidator::LOG_LEVEL.include?(
+        @options[:log_level].to_sym
+      )
+        OptionsValidator.write_error_and_exit("invalid log level #{@options[:log_level]}  : expected none, trace,"\
+                                                                                ' debug, info, warn, error, or fatal.')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module OptionsValidator
+    INVALID_PAIRS_RULES = { '--color' => '--no-color',
+                            '--json' => ['--no-json', '-y', '--yaml', '--hocon'],
+                            '--yaml' => ['--no-yaml', '-j', '--hocon'],
+                            '--hocon' => '--no-hocon',
+                            '-j' => ['--no-json', '--hocon'],
+                            '-y' => ['--no-yaml', '-j', '--hocon'],
+                            '--puppet' => ['--no-puppet', '--no-ruby', '--no-custom-facts'],
+                            '-p' => ['--no-puppet', '--no-ruby', '--no-custom-facts'],
+                            '--no-external-facts' => '--external-dir',
+                            '--custom-dir' => ['--no-custom-facts', '--no-ruby'] }.freeze
+    DUPLICATED_OPTIONS_RULES = { '-j' => '--json', '-y' => '--yaml', '-p' => '--puppet', '-h' => '--help',
+                                 '-v' => '--version', '-l' => '--log-level', '-d' => '--debug',
+                                 '-c' => '--config' }.freeze
+    LOG_LEVEL = %i[none trace debug info warn error fatal].freeze
+
+    def self.validate(options)
+      DUPLICATED_OPTIONS_RULES.each do |key, value|
+        if options.include?(key) && options.include?(value)
+          write_error_and_exit("option #{value} cannot be specified more than once.")
+        end
+      end
+
+      INVALID_PAIRS_RULES.each do |key, value|
+        common_values = [value].flatten & options
+        if options.include?(key) && common_values.any?
+          write_error_and_exit("#{key} and #{common_values.first} options conflict: please specify only one.")
+        end
+      end
+    end
+
+    def self.write_error_and_exit(message)
+      log = Facter::Log.new(self)
+      log.error(message, true)
+      Cli.start(['--help'])
+      exit 1
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Facter
+  module PriorityOptions
+    def augment_with_priority_options!(priority_options)
+      priority_options.each do |key, val|
+        @options[key.to_sym] = val
+        @options[key.to_sym] = '' if key == 'log_level' && val == 'log_level'
+      end
+    end
+  end
+end

data/lib/framework/detector/os_detector.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+class OsDetector
+  include Singleton
+
+  attr_reader :identifier, :version, :hierarchy
+
+  def initialize(*_args)
+    @identifier = detect
+    @hierarchy = create_hierarchy(@identifier)
+  end
+
+  def detect
+    host_os = RbConfig::CONFIG['host_os']
+    @identifier = case host_os
+                  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+                    :windows
+                  when /darwin|mac os/
+                    :macosx
+                  when /linux/
+                    detect_distro
+                  when /solaris|bsd/
+                    :solaris
+                  when /aix/
+                    :aix
+                  else
+                    raise "unknown os: #{host_os.inspect}"
+                  end
+  end
+
+  private
+
+  def detect_distro
+    [Facter::Resolvers::OsRelease,
+     Facter::Resolvers::RedHatRelease,
+     Facter::Resolvers::SuseRelease].each do |resolver|
+      @identifier = resolver.resolve(:identifier)
+      @version = resolver.resolve(:version)
+      break if @identifier
+    end
+
+    @identifier
+  end
+
+  def create_hierarchy(operating_system) # rubocop:disable Metrics/CyclomaticComplexity:
+    return [] unless operating_system
+
+    case operating_system.to_sym
+    when :ubuntu
+      %w[Debian]
+    when :fedora
+      %w[El]
+    when :amzn
+      %w[El]
+    when :rhel
+      %w[El]
+    when :centos
+      %w[El]
+    when :opensuse
+      %w[Sles]
+    else
+      [operating_system.to_s.capitalize]
+    end
+  end
+end

data/lib/framework/formatters/formatter_factory.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Facter
+  class FormatterFactory
+    def self.build(options)
+      return JsonFactFormatter.new if options[:json]
+      return YamlFactFormatter.new if options[:yaml]
+      return HoconFactFormatter.new if options[:hocon]
+
+      LegacyFactFormatter.new
+    end
+  end
+end

data/lib/framework/formatters/formatter_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  class FormatterHelper
+    class << self
+      def retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+        facts_to_display = {}
+        user_queries.each do |user_query|
+          fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
+
+          splitted_user_query = Utils.split_user_query(user_query)
+          printable_value = fact_collection.dig(*splitted_user_query)
+          facts_to_display.merge!(user_query => printable_value)
+        end
+
+        Facter::Utils.sort_hash_by_key(facts_to_display)
+      end
+
+      def retrieve_fact_collection(resolved_facts)
+        fact_collection = FactCollection.new.build_fact_collection!(resolved_facts)
+        Facter::Utils.sort_hash_by_key(fact_collection)
+      end
+
+      def retrieve_fact_value_for_single_query(user_query, resolved_facts)
+        fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
+        fact_collection = Facter::Utils.sort_hash_by_key(fact_collection)
+        splitted_user_query = Utils.split_user_query(user_query)
+        fact_collection.dig(*splitted_user_query)
+      end
+
+      private
+
+      def build_fact_collection_for_user_query(user_query, resolved_facts)
+        facts_for_query = resolved_facts.select { |resolved_fact| resolved_fact.user_query == user_query }
+        FactCollection.new.build_fact_collection!(facts_for_query)
+      end
+    end
+  end
+end

data/lib/framework/formatters/hocon_fact_formatter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  class HoconFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      return if user_queries.count < 1
+      return format_for_multiple_user_queries(user_queries, resolved_facts) if user_queries.count > 1
+
+      user_query = user_queries.first
+      return format_for_no_query(resolved_facts) if user_query.empty?
+      return format_for_single_user_query(user_queries.first, resolved_facts) unless user_query.empty?
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('Formatting for no user query')
+      fact_collection = FormatterHelper.retrieve_fact_collection(resolved_facts)
+      hash_to_hocon(fact_collection)
+    end
+
+    def format_for_multiple_user_queries(user_queries, resolved_facts)
+      @log.debug('Formatting for multiple user queries')
+
+      facts_to_display = FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+      hash_to_hocon(facts_to_display)
+    end
+
+    def format_for_single_user_query(user_query, resolved_facts)
+      @log.debug('Formatting for single user query')
+
+      fact_value = FormatterHelper.retrieve_fact_value_for_single_query(user_query, resolved_facts)
+
+      return '' unless fact_value
+
+      fact_value.class == Hash ? hash_to_hocon(fact_value) : fact_value
+    end
+
+    def hash_to_hocon(fact_collection)
+      render_opts = Hocon::ConfigRenderOptions.new(false, false, true, false)
+      Hocon::ConfigFactory.parse_string(fact_collection.to_json).root.render(render_opts)
+    end
+  end
+end

data/lib/framework/formatters/json_fact_formatter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  class JsonFactFormatter
+    def initialize
+      @log = Facter::Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      if user_queries.count == 1 && user_queries.first.empty?
+        format_for_no_query(resolved_facts)
+      else
+        format_for_user_queries(user_queries, resolved_facts)
+      end
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('No user query provided')
+
+      fact_collection = FormatterHelper.retrieve_fact_collection(resolved_facts)
+      JSON.pretty_generate(fact_collection)
+    end
+
+    def format_for_user_queries(user_queries, resolved_facts)
+      @log.debug('User provided a query')
+
+      facts_to_display = FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+      JSON.pretty_generate(facts_to_display)
+    end
+  end
+end

data/lib/framework/formatters/legacy_fact_formatter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Facter
+  class LegacyFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(resolved_facts)
+      user_queries = resolved_facts.uniq(&:user_query).map(&:user_query)
+
+      return if user_queries.count < 1
+      return format_for_multiple_user_queries(user_queries, resolved_facts) if user_queries.count > 1
+
+      user_query = user_queries.first
+      return format_for_no_query(resolved_facts) if user_query.empty?
+      return format_for_single_user_query(user_queries.first, resolved_facts) unless user_query.empty?
+    end
+
+    private
+
+    def format_for_no_query(resolved_facts)
+      @log.debug('Formatting for no user query')
+      fact_collection = Facter::FormatterHelper.retrieve_fact_collection(resolved_facts)
+      pretty_json = hash_to_facter_format(fact_collection)
+
+      pretty_json = remove_enclosing_accolades(pretty_json)
+      remove_comma_and_quation(pretty_json)
+    end
+
+    def format_for_multiple_user_queries(user_queries, resolved_facts)
+      @log.debug('Formatting for multiple user queries')
+
+      facts_to_display = Facter::FormatterHelper.retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
+
+      facts_to_display.each { |k, v| facts_to_display[k] = v.nil? ? '' : v }
+      pretty_json = hash_to_facter_format(facts_to_display)
+      pretty_json = remove_enclosing_accolades(pretty_json)
+      pretty_json = remove_comma_and_quation(pretty_json)
+
+      @log.debug('Remove quotes from value if value is a string')
+      pretty_json.gsub(/^(\S*) => \"(.*)\"/, '\1 => \2')
+    end
+
+    def format_for_single_user_query(user_query, resolved_facts)
+      @log.debug('Formatting for single user query')
+
+      fact_value = Facter::FormatterHelper.retrieve_fact_value_for_single_query(user_query, resolved_facts)
+
+      return fact_value if fact_value.is_a?(String)
+
+      pretty_json = fact_value.nil? ? '' : hash_to_facter_format(fact_value)
+
+      @log.debug('Remove quotes from value if it is a simple string')
+      pretty_json.gsub(/^"(.*)\"/, '\1')
+    end
+
+    def hash_to_facter_format(facts_hash)
+      @log.debug('Converting hash to pretty json')
+      pretty_json = JSON.pretty_generate(facts_hash)
+
+      @log.debug('Change key value delimiter from : to =>')
+      pretty_json.gsub!(/^(.*?)(:)/, '\1 =>')
+
+      @log.debug('Remove quotes from parent nodes')
+      pretty_json.gsub!(/\"(.*)\"\ =>/, '\1 =>')
+
+      pretty_json
+    end
+
+    def remove_enclosing_accolades(pretty_fact_json)
+      @log.debug('Removing enclosing accolades')
+      pretty_fact_json = pretty_fact_json[1..-2]
+
+      @log.debug('Remove empty lines')
+      pretty_fact_json.gsub!(/^$\n/, '')
+
+      @log.debug('Fix indentation after removing enclosed accolades')
+      pretty_fact_json = pretty_fact_json.gsub(/^\s\s(.*)$/, '\1')
+
+      @log.debug('remove comas from query results')
+      pretty_fact_json.gsub(/^},/, '}')
+    end
+
+    def remove_comma_and_quation(output)
+      @log.debug('Remove unnecessary comma and quotation marks on root facts')
+      output.split("\n").map! { |line| line.match(/^[\s]+/) ? line : line.gsub(/,$|\"/, '') }.join("\n")
+    end
+  end
+end

data/lib/framework/formatters/yaml_fact_formatter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Facter
+  class YamlFactFormatter
+    def initialize
+      @log = Log.new(self)
+    end
+
+    def format(fact_hash)
+      yaml_pretty = YAML.dump(JSON.parse(JsonFactFormatter.new.format(fact_hash)))
+
+      @log.debug('Replace ---  from yaml beginning, to keep it compatible with C facter')
+      yaml_pretty.gsub(/^---[\r\n]+/, '')
+    end
+  end
+end