openfact 5.0.0.rc0

data/lib/facter/facts/windows/ruby/platform.rb

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

data/lib/facter/facts/windows/ruby/sitedir.rb

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

data/lib/facter/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/facter/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::Windows::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/facter/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/facter/facts/windows/sshalgorithmkey.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/sshfp_algorithm.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        privileged = Facter::Resolvers::Identity.resolve(:privileged)
+
+        return facts unless privileged
+
+        result = Facter::Resolvers::Windows::Ssh.resolve(:ssh)
+
+        result&.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end

data/lib/facter/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/facter/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/facter/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/facter/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/facter/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::Windows::Timezone.resolve(:timezone)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

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

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

data/lib/facter/framework/benchmarking/timer.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+module Facter
+  module Framework
+    module Benchmarking
+      class Timer
+        class << self
+          def measure(fact_name, prefix_message = '', &block)
+            if Options[:timing]
+              time = Benchmark.measure(&block)
+
+              log = "fact '#{fact_name}', took: #{time.format('%r')} seconds"
+              prefix_message = "#{prefix_message} " unless prefix_message.empty?
+              puts "#{prefix_message}#{log}"
+            else
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/framework/cli/cli.rb

@@ -0,0 +1,233 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'thor'
+
+module Facter
+  class Cli < Thor
+    class_option :color,
+                 type: :boolean,
+                 desc: 'Enable color output.'
+
+    class_option :no_color,
+                 type: :boolean,
+                 desc: 'Disable 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 :hocon,
+                 type: :boolean,
+                 desc: 'Output in Hocon format.'
+
+    class_option :json,
+                 aliases: '-j',
+                 type: :boolean,
+                 desc: 'Output in JSON format.'
+
+    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 :no_block,
+                 type: :boolean,
+                 desc: 'Disable fact blocking.'
+
+    class_option :no_cache,
+                 type: :boolean,
+                 desc: 'Disable loading and refreshing facts from the cache'
+
+    class_option :no_custom_facts,
+                 type: :boolean,
+                 desc: 'Disable custom facts.'
+
+    class_option :no_external_facts,
+                 type: :boolean,
+                 desc: 'Disable external facts.'
+
+    class_option :no_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 :timing,
+                 type: :boolean,
+                 aliases: '-t',
+                 desc: 'Show how much time it took to resolve each fact'
+
+    class_option :sequential,
+                 type: :boolean,
+                 desc: 'Resolve facts sequentially'
+
+    class_option :http_debug,
+                 type: :boolean,
+                 desc: 'Whether to write HTTP request and responses to stderr. This should never be used in production.'
+
+    class_option :puppet,
+                 type: :boolean,
+                 aliases: '-p',
+                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+
+    desc '--man', 'Display manual.', hide: true
+    map ['--man'] => :man
+    def man(*args)
+      require 'erb'
+      negate_options = %w[block cache custom_facts external_facts]
+
+      template = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'man.erb')
+      erb = ERB.new(File.read(template), nil, '-')
+      erb.filename = template
+      puts erb.result(binding)
+    end
+
+    desc 'query', 'Default method', hide: true
+    def query(*args)
+      Facter.puppet_facts if options[:puppet]
+      output, status = Facter.to_user_output(@options, *args)
+      puts output
+
+      status = 1 if Facter::Log.errors?
+      exit status
+    end
+
+    desc 'arg_parser', 'Parse arguments', hide: true
+    def arg_parser(*args)
+      # ignore unknown options
+      args.reject! { |arg| arg.start_with?('-') }
+
+      Facter.values(@options, args)
+    end
+
+    desc '--version, -v', 'Print the version'
+    map ['--version', '-v'] => :version
+    def version(*_args)
+      puts Facter::VERSION
+    end
+
+    desc '--list-block-groups', 'List block groups'
+    map ['--list-block-groups'] => :list_block_groups
+    def list_block_groups
+      options = @options.map { |(k, v)| [k.to_sym, v] }.to_h
+      Facter::Options.init_from_cli(options)
+
+      block_groups = Facter::FactGroups.new.groups.to_yaml.lines[1..-1].join
+      block_groups.gsub!(/:\s*\n/, "\n")
+
+      puts block_groups
+    end
+
+    desc '--list-cache-groups', 'List cache groups'
+    map ['--list-cache-groups'] => :list_cache_groups
+    def list_cache_groups
+      options = @options.map { |(k, v)| [k.to_sym, v] }.to_h
+      Facter::Options.init_from_cli(options)
+
+      cache_groups = Facter::FactGroups.new.groups.to_yaml.lines[1..-1].join
+      cache_groups.gsub!(/:\s*\n/, "\n")
+
+      puts cache_groups
+    end
+
+    desc '--help, -h', 'Help for all arguments'
+    def help(*args)
+      help_string = +''
+      help_string << help_header(args)
+      help_string << add_class_options_to_help
+      help_string << add_commands_to_help
+
+      puts help_string
+    end
+
+    no_commands do
+      def help_header(_args)
+        path = File.join(File.dirname(__FILE__), '../../')
+
+        Facter::Util::FileHelper.safe_read("#{path}fixtures/facter_help_header")
+      end
+
+      def add_class_options_to_help
+        help_class_options = +''
+        class_options = Cli.class_options
+        class_options.each do |class_option|
+          option = class_option[1]
+          next if option.hide
+
+          help_class_options << build_option(option.name, option.aliases, option.description)
+        end
+
+        help_class_options
+      end
+
+      def add_commands_to_help
+        help_command_options = +''
+        Cli.commands.values
+           .select { |command_class| command_class.instance_of?(Thor::Command) }
+           .each do |command|
+          help_command_options << build_option(
+            command['name'],
+            [command['usage'].split(',')[1]],
+            command['description']
+          )
+        end
+
+        help_command_options
+      end
+
+      def build_option(name, aliases, description)
+        name = name.tr('_', '-')
+        help_option = +''
+        help_option << aliases.join(',').rjust(10)
+        help_option << ' '
+        help_option << "[--#{name}]".ljust(30)
+        help_option << " #{description}"
+        help_option << "\n"
+
+        help_option
+      end
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    default_task :query
+  end
+end

data/lib/facter/framework/cli/cli_launcher.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../../../facter/framework/logging/logger'
+Facter::Log.output(STDERR)
+require_relative '../../../facter'
+require_relative '../../../facter/framework/cli/cli'
+
+class CliLauncher
+  class << self
+    def prepare_arguments(args, task = Facter::Cli.default_task)
+      args.unshift(task) unless
+        check_if_arguments_is_known(Facter::Cli.all_tasks, args) ||
+        check_if_arguments_is_known(Facter::Cli.instance_variable_get(:@map), args) ||
+        !task
+
+      reorder_program_arguments(args)
+    end
+
+    def start(args)
+      # stop parsing arguments if we don't recognize them
+      Thor.check_unknown_options!
+      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
+end

data/lib/facter/framework/config/config_reader.rb

@@ -0,0 +1,63 @@
+# 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) : {}
+      rescue StandardError => e
+        log.warn("Facter failed to read config file #{config_path} with the following error: #{e.message}")
+        @conf = {}
+      end
+
+      def clear
+        @conf = {}
+      end
+
+      private
+
+      def log
+        @log ||= Log.new(self)
+      end
+
+      def default_path
+        return '' if RUBY_PLATFORM == 'java'
+
+        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