facter 4.0.23

data/lib/facts/windows/ruby/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module Ruby
+      class Version
+        FACT_NAME = 'ruby.version'
+        ALIASES = 'rubyversion'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Ruby.resolve(:version)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facts/windows/scope6_interfaces.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Scope6Interfaces
+      FACT_NAME = 'scope6_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        arr = []
+        result = {}
+        interfaces = Facter::Resolvers::Networking.resolve(:interfaces)
+        interfaces&.each { |interface_name, info| result["scope6_#{interface_name}"] = info[:scope6] if info[:scope6] }
+
+        result.each { |fact, value| arr << Facter::ResolvedFact.new(fact, value, :legacy) }
+        arr
+      end
+    end
+  end
+end

data/lib/facts/windows/ssh.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Ssh
+      FACT_NAME = 'ssh'
+
+      def call_the_resolver
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+        ssh_info = Facter::Resolvers::Windows::Ssh.resolve(:ssh) if privileged
+        ssh_facts = {}
+        ssh_info&.each { |ssh| ssh_facts.merge!(create_ssh_fact(ssh)) }
+        Facter::ResolvedFact.new(FACT_NAME, ssh_facts.empty? ? nil : ssh_facts)
+      end
+
+      private
+
+      def create_ssh_fact(ssh)
+        { ssh.name.to_sym =>
+              { fingerprints: { sha1: ssh.fingerprint.sha1,
+                                sha256: ssh.fingerprint.sha256 },
+                key: ssh.key,
+                type: ssh.type } }
+      end
+    end
+  end
+end

data/lib/facts/windows/system_uptime/days.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module SystemUptime
+      class Days
+        FACT_NAME = 'system_uptime.days'
+        ALIASES = 'uptime_days'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Windows::Uptime.resolve(:days)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facts/windows/system_uptime/hours.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module SystemUptime
+      class Hours
+        FACT_NAME = 'system_uptime.hours'
+        ALIASES = 'uptime_hours'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Windows::Uptime.resolve(:hours)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facts/windows/system_uptime/seconds.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module SystemUptime
+      class Seconds
+        FACT_NAME = 'system_uptime.seconds'
+        ALIASES = 'uptime_seconds'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Windows::Uptime.resolve(:seconds)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facts/windows/system_uptime/uptime.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module SystemUptime
+      class Uptime
+        FACT_NAME = 'system_uptime.uptime'
+        ALIASES = 'uptime'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Windows::Uptime.resolve(:uptime)
+
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+        end
+      end
+    end
+  end
+end

data/lib/facts/windows/timezone.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Timezone
+      FACT_NAME = 'timezone'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::Timezone.resolve(:timezone)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/lib/facts/windows/virtualization/is_virtual.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module Virtualization
+      class IsVirtual
+        FACT_NAME = 'is_virtual'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Virtualization.resolve(:is_virtual)
+
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+      end
+    end
+  end
+end

data/lib/facts/windows/virtualization/virtual.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module Virtualization
+      class Virtual
+        FACT_NAME = 'virtual'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Virtualization.resolve(:virtual)
+
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+      end
+    end
+  end
+end

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