facter 4.0.28

data/lib/facts_utils/unit_converter.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Facter
+  module FactsUtils
+    class UnitConverter
+      class << self
+        def bytes_to_mb(value_in_bytes)
+          return unless value_in_bytes
+
+          value_in_bytes = value_in_bytes.to_i
+
+          (value_in_bytes / (1024.0 * 1024.0)).round(2)
+        end
+
+        def hertz_to_human_readable(speed)
+          speed = speed.to_i
+          return if !speed || speed.zero?
+
+          prefix = { 3 => 'k', 6 => 'M', 9 => 'G', 12 => 'T' }
+          power = Math.log10(speed).floor
+          validated_speed = power.zero? ? speed.to_f : speed.fdiv(10**power)
+          format('%<displayed_speed>.2f', displayed_speed: validated_speed).to_s + ' ' + prefix[power] + 'Hz'
+        end
+
+        def bytes_to_human_readable(bytes)
+          return unless bytes
+          return bytes.to_s + ' bytes' if bytes < 1024
+
+          number, multiple = determine_exponent(bytes)
+
+          "#{pad_number(number)} #{multiple}"
+        end
+
+        private
+
+        def pad_number(number)
+          number = number.to_s
+          number << '0' if number.split('.').last.length == 1
+          number
+        end
+
+        def determine_exponent(bytes)
+          prefix = %w[KiB MiB GiB TiB PiB EiB]
+          exp = (Math.log2(bytes) / 10.0).floor
+          converted_number = (100.0 * (bytes / 1024.0**exp)).round / 100.0
+
+          if (converted_number - 1024.0).abs < Float::EPSILON
+            exp += 1
+            converted_number = 1.00
+          end
+          multiple = prefix[exp - 1] || 'bytes'
+
+          converted_number = bytes if multiple == 'bytes'
+          [converted_number, multiple]
+        end
+      end
+    end
+  end
+end

data/lib/facts_utils/uptime_parser.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Facter
+  class UptimeParser
+    SECS_IN_A_DAY = 86_400
+    SECS_IN_AN_HOUR = 3_600
+    SECS_IN_A_MINUTE = 60
+
+    @log = Facter::Log.new(self)
+
+    class << self
+      def uptime_seconds_unix
+        uptime_proc_uptime || uptime_sysctl || uptime_executable
+      end
+
+      private
+
+      def uptime_proc_uptime
+        output = Facter::Core::Execution.execute("/bin/cat #{uptime_file}", logger: @log)
+
+        output.chomp.split(' ').first.to_i unless output.empty?
+      end
+
+      def uptime_sysctl
+        output = Facter::Core::Execution.execute("sysctl -n #{uptime_sysctl_variable}", logger: @log)
+
+        compute_uptime(Time.at(output.match(/\d+/)[0].to_i)) unless output.empty?
+      end
+
+      def uptime_executable
+        output = Facter::Core::Execution.execute(uptime_executable_cmd, logger: @log)
+
+        return unless output
+
+        up = 0
+        output_calculator_methods.find { |method| up = send(method, output) }
+        up || 0
+      end
+
+      def uptime_file
+        '/proc/uptime'
+      end
+
+      def uptime_sysctl_variable
+        'kern.boottime'
+      end
+
+      def uptime_executable_cmd
+        'uptime'
+      end
+
+      def output_calculator_methods
+        %i[
+          calculate_days_hours_minutes
+          calculate_days_hours
+          calculate_days_minutes
+          calculate_days
+          calculate_hours_minutes
+          calculate_hours
+          calculate_minutes
+        ]
+      end
+
+      def compute_uptime(time)
+        (Time.now - time).to_i
+      end
+
+      # Regexp handles Solaris, AIX, HP-UX, and Tru64.
+      # 'day(?:s|\(s\))?' says maybe 'day', 'days',
+      #   or 'day(s)', and don't set $2.
+      def calculate_days_hours_minutes(output)
+        return unless output =~ /(\d+) day(?:s|\(s\))?,?\s+(\d+):-?(\d+)/
+
+        SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+          SECS_IN_AN_HOUR * Regexp.last_match(2).to_i +
+          SECS_IN_A_MINUTE * Regexp.last_match(3).to_i
+      end
+
+      def calculate_days_hours(output)
+        return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) hr(?:s|\(s\))?,/
+
+        SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+          SECS_IN_AN_HOUR * Regexp.last_match(2).to_i
+      end
+
+      def calculate_days_minutes(output)
+        return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) min(?:s|\(s\))?,/
+
+        SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+          SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+      end
+
+      def calculate_days(output)
+        return unless output =~ /(\d+) day(?:s|\(s\))?,/
+
+        SECS_IN_A_DAY * Regexp.last_match(1).to_i
+      end
+
+      # must anchor to 'up' to avoid matching time of day
+      # at beginning of line. Certain versions of uptime on
+      # Solaris may insert a '-' into the minutes field.
+      def calculate_hours_minutes(output)
+        return unless output =~ /up\s+(\d+):-?(\d+),/
+
+        SECS_IN_AN_HOUR * Regexp.last_match(1).to_i +
+          SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+      end
+
+      def calculate_hours(output)
+        return unless output =~ /(\d+) hr(?:s|\(s\))?,/
+
+        SECS_IN_AN_HOUR * Regexp.last_match(1).to_i
+      end
+
+      def calculate_minutes(output)
+        return unless output =~ /(\d+) min(?:s|\(s\))?,/
+
+        SECS_IN_A_MINUTE * Regexp.last_match(1).to_i
+      end
+    end
+  end
+end

data/lib/facts_utils/windows_release_finder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Facter
+  class WindowsReleaseFinder
+    class << self
+      def find_release(input)
+        version = input[:version]
+        return unless version
+
+        consumerrel = input[:consumerrel]
+        description = input[:description]
+        kernel_version = input[:kernel_version]
+
+        if version =~ /10.0/
+          check_version_10(consumerrel, kernel_version)
+        else
+          check_version_6(version, consumerrel) || check_version_5(version, consumerrel, description) || version
+        end
+      end
+
+      private
+
+      def check_version_10(consumerrel, kernel_version)
+        build_number = kernel_version[/([^.]*)$/].to_i
+        if consumerrel
+          '10'
+        elsif build_number >= 17_623
+          '2019'
+        else
+          '2016'
+        end
+      end
+
+      def check_version_6(version, consumerrel)
+        hash = {}
+        hash['6.3'] = consumerrel ? '8.1' : '2012 R2'
+        hash['6.2'] = consumerrel ? '8' : '2012'
+        hash['6.1'] = consumerrel ? '7' : '2008 R2'
+        hash['6.0'] = consumerrel ? 'Vista' : '2008'
+        hash[version]
+      end
+
+      def check_version_5(version, consumerrel, description)
+        return unless version =~ /5.2/
+        return 'XP' if consumerrel
+
+        description == 'R2' ? '2003 R2' : '2003'
+      end
+    end
+  end
+end

data/lib/framework/cli/cli.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+module Facter
+  class Cli < Thor
+    check_unknown_options!
+
+    class_option :color,
+                 type: :boolean,
+                 desc: 'Enable color output.'
+
+    class_option :config,
+                 aliases: '-c',
+                 type: :string,
+                 desc: 'The location of the config file.'
+
+    class_option :custom_dir,
+                 type: :string,
+                 repeatable: true,
+                 desc: 'A directory to use for custom facts.'
+
+    class_option :debug,
+                 aliases: '-d',
+                 type: :boolean,
+                 desc: 'Enable debug output.'
+
+    class_option :external_dir,
+                 type: :string,
+                 repeatable: true,
+                 desc: 'A directory to use for external facts.'
+
+    class_option :help,
+                 hide: true,
+                 aliases: '-h',
+                 type: :boolean,
+                 desc: 'Print this help message.'
+
+    class_option :hocon,
+                 type: :boolean,
+                 desc: 'Output in Hocon format.'
+
+    class_option :json,
+                 aliases: '-j',
+                 type: :boolean,
+                 desc: 'Output in JSON format.'
+
+    class_option :list_block_groups,
+                 type: :boolean,
+                 desc: 'List the names of all blockable fact groups.'
+
+    class_option :list_cache_groups,
+                 type: :boolean,
+                 desc: 'List the names of all cacheable fact groups.'
+
+    class_option :log_level,
+                 aliases: '-l',
+                 type: :string,
+                 desc: 'Set logging level. Supported levels are: none, trace, debug, info, warn, error, and fatal.'
+
+    class_option :block,
+                 type: :boolean,
+                 desc: 'Disable fact blocking.'
+
+    class_option :cache,
+                 type: :boolean,
+                 desc: 'Disable loading and refreshing facts from the cache'
+
+    class_option :custom_facts,
+                 type: :boolean,
+                 desc: 'Disable custom facts.'
+
+    class_option :external_facts,
+                 type: :boolean,
+                 desc: 'Disable external facts.'
+
+    class_option :ruby,
+                 type: :boolean,
+                 desc: 'Disable loading Ruby, facts requiring Ruby, and custom facts.'
+
+    class_option :trace,
+                 type: :boolean,
+                 desc: 'Enable backtraces for custom facts.'
+
+    class_option :verbose,
+                 type: :boolean,
+                 desc: 'Enable verbose (info) output.'
+
+    class_option :show_legacy,
+                 type: :boolean,
+                 desc: 'Show legacy facts when querying all facts.'
+
+    class_option :yaml,
+                 aliases: '-y',
+                 type: :boolean,
+                 desc: 'Output in YAML format.'
+
+    class_option :strict,
+                 type: :boolean,
+                 desc: 'Enable more aggressive error reporting.'
+
+    class_option :puppet,
+                 type: :boolean,
+                 aliases: '-p',
+                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+
+    desc 'query', 'Default method', hide: true
+    desc '[options] [query] [query] [...]', ''
+    def query(*args)
+      output, status = Facter.to_user_output(@options, *args)
+      puts output
+
+      status = 1 if Facter::Log.errors?
+      exit status
+    end
+
+    desc '--version, -v', 'Print the version', hide: true
+    map ['--version', '-v'] => :version
+    def version
+      puts FACTER_VERSION.to_s
+    end
+
+    desc '--list-block-groups', 'List block groups'
+    map ['--list-block-groups'] => :list_block_groups
+    def list_block_groups(*_args)
+      puts Facter::FactGroups.new.groups.to_yaml.lines[1..-1].join
+    end
+
+    desc '--list-cache-groups', 'List cache groups'
+    map ['--list-cache-groups'] => :list_cache_groups
+    def list_cache_groups(*_args)
+      puts Facter::FactGroups.new.groups.to_yaml.lines[1..-1].join
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    default_task :query
+  end
+end

data/lib/framework/cli/cli_launcher.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'thor'
+require "#{ROOT_DIR}/lib/framework/logging/logger.rb"
+Facter::Log.output(STDERR)
+require "#{ROOT_DIR}/lib/facter"
+require "#{ROOT_DIR}/lib/framework/cli/cli"
+
+class CliLauncher
+  def initialize(args)
+    @args = args
+  end
+
+  def validate_options
+    Facter::OptionsValidator.validate(@args)
+  end
+
+  def prepare_arguments
+    @args.unshift(Facter::Cli.default_task) unless
+      check_if_arguments_is_known(Facter::Cli.all_tasks, @args) ||
+      check_if_arguments_is_known(Facter::Cli.instance_variable_get(:@map), @args)
+
+    @args = reorder_program_arguments(@args)
+  end
+
+  def start
+    Facter::Cli.start(@args, debug: true)
+  rescue Thor::UnknownArgumentError => e
+    Facter::OptionsValidator.write_error_and_exit("unrecognised option '#{e.unknown.first}'")
+  end
+
+  private
+
+  def check_if_arguments_is_known(known_arguments, program_arguments)
+    program_arguments.each do |argument|
+      return true if known_arguments.key?(argument)
+    end
+
+    false
+  end
+
+  def reorder_program_arguments(program_arguments)
+    priority_arguments = Facter::Cli.instance_variable_get(:@map)
+
+    priority_args = []
+    normal_args = []
+
+    program_arguments.each do |argument|
+      if priority_arguments.include?(argument)
+        priority_args << argument
+      else
+        normal_args << argument
+      end
+    end
+
+    priority_args.concat(normal_args)
+  end
+end

data/lib/framework/config/config_reader.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  class ConfigReader
+    class << self
+      attr_accessor :conf
+
+      def init(config_path = nil)
+        config_path ||= default_path
+        refresh_config(config_path)
+        self
+      end
+
+      def block_list
+        @conf['facts'] && @conf['facts']['blocklist']
+      end
+
+      def ttls
+        @conf['facts'] && @conf['facts']['ttls']
+      end
+
+      def global
+        @conf['global']
+      end
+
+      def cli
+        @conf['cli']
+      end
+
+      def fact_groups
+        @conf['fact-groups']
+      end
+
+      def refresh_config(config_path)
+        @conf = File.readable?(config_path) ? Hocon.load(config_path) : {}
+      end
+
+      private
+
+      def default_path
+        os = OsDetector.instance.identifier
+
+        windows_path = File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'etc', 'facter.conf')
+        linux_path = File.join('/', 'etc', 'puppetlabs', 'facter', 'facter.conf')
+
+        os == :windows ? windows_path : linux_path
+      end
+    end
+  end
+end