facter 4.0.51 → 4.0.52

data/lib/facter/facts/sles/os/distro/codename.rb

@@ -6,13 +6,12 @@ module Facts
       module Distro
         class Codename
           FACT_NAME = 'os.distro.codename'
-          ALIASES = 'lsbdistcodename'
 
           def call_the_resolver
-            fact_value = Facter::Resolvers::LsbRelease.resolve(:codename)
+            fact_value = Facter::Resolvers::OsRelease.resolve(:version_codename)
+            fact_value = 'n/a' if !fact_value || fact_value.empty?
 
-            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end
         end
       end

data/lib/facter/facts/sles/os/distro/description.rb

@@ -6,13 +6,10 @@ module Facts
       module Distro
         class Description
           FACT_NAME = 'os.distro.description'
-          ALIASES = 'lsbdistdescription'
 
           def call_the_resolver
-            fact_value = Facter::Resolvers::LsbRelease.resolve(:description)
-
-            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+            fact_value = Facter::Resolvers::OsRelease.resolve(:pretty_name)
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end
         end
       end

data/lib/facter/facts/sles/os/distro/id.rb

@@ -6,13 +6,14 @@ module Facts
       module Distro
         class Id
           FACT_NAME = 'os.distro.id'
-          ALIASES = 'lsbdistid'
 
           def call_the_resolver
-            fact_value = Facter::Resolvers::LsbRelease.resolve(:distributor_id)
-
-            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
-             Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+            fact_value = if Facter::Resolvers::OsRelease.resolve(:version_id).start_with?('12')
+                           'SUSE LINUX'
+                         else
+                           'SUSE'
+                         end
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
           end
         end
       end

data/lib/facter/facts/sles/os/distro/release.rb

@@ -9,20 +9,25 @@ module Facts
           ALIASES = %w[lsbdistrelease lsbmajdistrelease lsbminordistrelease].freeze
 
           def call_the_resolver
-            fact_value = Facter::Resolvers::LsbRelease.resolve(:release)
-            return Facter::ResolvedFact.new(FACT_NAME, nil) unless fact_value
+            version = Facter::Resolvers::OsRelease.resolve(:version_id)
+            fact_value = build_fact_list(version)
 
-            versions = fact_value.split('.')
-            release = {
-              'full' => fact_value,
-              'major' => versions[0],
-              'minor' => versions[1]
-            }
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES[0], fact_value[:full], :legacy),
+             Facter::ResolvedFact.new(ALIASES[1], fact_value[:major], :legacy),
+             Facter::ResolvedFact.new(ALIASES[2], fact_value[:minor], :legacy)]
+          end
 
-            [Facter::ResolvedFact.new(FACT_NAME, release),
-             Facter::ResolvedFact.new(ALIASES[0], fact_value, :legacy),
-             Facter::ResolvedFact.new(ALIASES[1], versions[0], :legacy),
-             Facter::ResolvedFact.new(ALIASES[2], versions[1], :legacy)]
+          def build_fact_list(version)
+            if version.include?('.')
+              {
+                full: version,
+                major: version.split('.').first,
+                minor: version.split('.').last
+              }
+            else
+              { full: version, major: version, minor: nil }
+            end
           end
         end
       end

data/lib/facter/facts/ubuntu/lsbdistrelease.rb

@@ -15,8 +15,8 @@ module Facts
         version = fact_value.split('.')
 
         [Facter::ResolvedFact.new(FACT_NAME, fact_value, :legacy),
-         Facter::ResolvedFact.new(ALIASES[0], version[0], :legacy),
-         Facter::ResolvedFact.new(ALIASES[1], version[1], :legacy)]
+         Facter::ResolvedFact.new(ALIASES[0], "#{version[0]}.#{version[1]}", :legacy),
+         Facter::ResolvedFact.new(ALIASES[1], version[2], :legacy)]
       end
     end
   end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    class AzMetadata
+      FACT_NAME = 'az_metadata'
+
+      def initialize
+        @virtual = Facter::Util::Facts::VirtualDetector.new
+      end
+
+      def call_the_resolver
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless azure_hypervisor?
+
+        fact_value = Facter::Resolvers::Az.resolve(:metadata)
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
+      end
+
+      private
+
+      def azure_hypervisor?
+        @virtual.platform == 'hyperv'
+      end
+    end
+  end
+end

data/lib/facter/facts/windows/cloud/provider.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module Cloud
+      class Provider
+        FACT_NAME = 'cloud.provider'
+
+        def call_the_resolver
+          az_metadata = Facter::Resolvers::Az.resolve(:metadata)
+
+          Facter::ResolvedFact.new(FACT_NAME, az_metadata&.empty? ? nil : 'azure')
+        end
+      end
+    end
+  end
+end

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

@@ -134,9 +134,9 @@ module Facter
 
     desc '--list-block-groups', 'List block groups'
     map ['--list-block-groups'] => :list_block_groups
-    def list_block_groups(*args)
+    def list_block_groups
       options = @options.map { |(k, v)| [k.to_sym, v] }.to_h
-      Facter::Options.init_from_cli(options, args)
+      Facter::Options.init_from_cli(options)
 
       block_groups = Facter::FactGroups.new.groups.to_yaml.lines[1..-1].join
       block_groups.gsub!(/:\s*\n/, "\n")
@@ -146,9 +146,9 @@ module Facter
 
     desc '--list-cache-groups', 'List cache groups'
     map ['--list-cache-groups'] => :list_cache_groups
-    def list_cache_groups(*args)
+    def list_cache_groups
       options = @options.map { |(k, v)| [k.to_sym, v] }.to_h
-      Facter::Options.init_from_cli(options, args)
+      Facter::Options.init_from_cli(options)
 
       cache_groups = Facter::FactGroups.new.groups.to_yaml.lines[1..-1].join
       cache_groups.gsub!(/:\s*\n/, "\n")
@@ -156,7 +156,7 @@ module Facter
       puts cache_groups
     end
 
-    desc '--puppet, -p', '(NOT SUPPORTED)Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+    desc '--puppet, -p', 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
     map ['--puppet', '-p'] => :puppet
     def puppet(*args)
       Facter.puppet_facts

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

@@ -45,6 +45,8 @@ module Facter
       end
 
       def default_path
+        return '' if RUBY_PLATFORM == 'java'
+
         os = OsDetector.instance.identifier
 
         windows_path = File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'etc', 'facter.conf')

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

@@ -7,7 +7,15 @@ module Facter
     attr_accessor :groups_ttls
     attr_reader :groups, :block_list, :facts_ttls
 
-    STRING_TO_SECONDS = { 'seconds' => 1, 'minutes' => 60, 'hours' => 3600, 'days' => 3600 * 24 }.freeze
+    STRING_TO_SECONDS = { 'ns' => 1.fdiv(1_000_000_000), 'nanos' => 1.fdiv(1_000_000_000),
+                          'nanoseconds' => 1.fdiv(1_000_000_000),
+                          'us' => 1.fdiv(1_000_000), 'micros' => 1.fdiv(1_000_000), 'microseconds' => 1.fdiv(1_000_000),
+                          '' => 1.fdiv(1000), 'ms' => 1.fdiv(1000), 'milis' => 1.fdiv(1000),
+                          'milliseconds' => 1.fdiv(1000),
+                          's' => 1, 'seconds' => 1,
+                          'm' => 60, 'minutes' => 60,
+                          'h' => 3600, 'hours' => 3600,
+                          'd' => 3600 * 24, 'days' => 3600 * 24 }.freeze
 
     def initialize
       @groups = Facter::Config::FACT_GROUPS.dup
@@ -103,7 +111,22 @@ module Facter
 
     def ttls_to_seconds(ttls)
       duration, unit = ttls.split(' ', 2)
-      duration.to_i * STRING_TO_SECONDS[unit]
+      unit = '' if duration && !unit
+      unit = append_s(unit)
+      seconds = STRING_TO_SECONDS[unit]
+      if seconds
+        (duration.to_i * seconds).to_i
+      else
+        log = Log.new(self)
+        log.error("Could not parse time unit #{unit} (try #{STRING_TO_SECONDS.keys.reject(&:empty?).join(', ')})")
+        nil
+      end
+    end
+
+    def append_s(unit)
+      return unit + 's' if unit.length > 2 && unit[-1] != 's'
+
+      unit
     end
   end
 end

data/lib/facter/framework/core/cache_manager.rb

@@ -209,7 +209,11 @@ cache_format_version is incorrect!")
     def delete_cache(group_name)
       cache_file_name = File.join(@cache_dir, group_name)
 
-      File.delete(cache_file_name) if File.readable?(cache_file_name)
+      begin
+        File.delete(cache_file_name) if File.readable?(cache_file_name)
+      rescue Errno::EACCES => e
+        @log.warn("Could not delete cache: #{e.message}")
+      end
     end
   end
 end

data/lib/facter/framework/core/fact_filter.rb

@@ -5,8 +5,8 @@ module Facter
   # e.g. os.release.major is the user query, os.release is the fact
   # and major is the filter criteria inside tha fact
   class FactFilter
-    def filter_facts!(searched_facts)
-      filter_legacy_facts!(searched_facts)
+    def filter_facts!(searched_facts, user_query)
+      filter_legacy_facts!(searched_facts) if user_query.empty?
       filter_blocked_legacy_facts!(searched_facts)
 
       searched_facts.each do |fact|
@@ -32,7 +32,7 @@ module Facter
     end
 
     def filter_legacy_facts!(resolved_facts)
-      return unless !Options[:show_legacy] && Options[:user_query].empty?
+      return if Options[:show_legacy]
 
       resolved_facts.reject!(&:legacy?)
     end

data/lib/facter/framework/core/fact_loaders/fact_loader.rb

@@ -48,7 +48,6 @@ module Facter
     def load_internal_facts(options)
       @log.debug('Loading internal facts')
       internal_facts = []
-
       if options[:user_query] || options[:show_legacy]
         # if we have a user query, then we must search in core facts and legacy facts
         @log.debug('Loading all internal facts')

data/lib/facter/framework/core/fact_manager.rb

@@ -29,7 +29,7 @@ module Facter
       resolved_facts = resolved_facts.concat(cached_facts)
       cache_manager.cache_facts(resolved_facts)
 
-      FactFilter.new.filter_facts!(resolved_facts)
+      FactFilter.new.filter_facts!(resolved_facts, user_query)
 
       log_resolved_facts(resolved_facts)
       resolved_facts
@@ -40,7 +40,7 @@ module Facter
 
       searched_facts = QueryParser.parse(user_query, loaded_facts_hash)
       resolved_facts = @internal_fact_mgr.resolve_facts(searched_facts)
-      FactFilter.new.filter_facts!(resolved_facts)
+      FactFilter.new.filter_facts!(resolved_facts, user_query)
 
       resolved_facts
     end
@@ -48,7 +48,9 @@ module Facter
     private
 
     def parse_user_query(user_query)
-      loaded_facts = @fact_loader.load(Options.get)
+      options = Options.get
+      options[:user_query] = user_query
+      loaded_facts = @fact_loader.load(options)
 
       QueryParser.parse(user_query, loaded_facts)
     end

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

@@ -41,10 +41,9 @@ module Facter
         store(ConfigFileOptions.get)
       end
 
-      def init_from_cli(cli_options = {}, user_query = nil)
+      def init_from_cli(cli_options = {})
         Facter::OptionStore.cli = true
         Facter::OptionStore.show_legacy = false
-        Facter::OptionStore.user_query = user_query
         Facter::OptionStore.trace = cli_options[:trace]
         OptionStore.set(:config, cli_options[:config])
         ConfigFileOptions.init(cli_options[:config])

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

@@ -13,7 +13,6 @@ module Facter
     @ruby = true
     @external_facts = true
     @config = nil
-    @user_query = []
     @strict = false
     @json = false
     @cache = true
@@ -41,7 +40,7 @@ module Facter
       attr_reader :debug, :verbose, :log_level, :show_legacy,
                   :custom_facts, :blocked_facts, :ruby, :external_facts
 
-      attr_accessor :config, :user_query, :strict, :json,
+      attr_accessor :config, :strict, :json,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
                     :config_file_external_dir, :default_external_dir, :fact_groups,
                     :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers
@@ -171,7 +170,6 @@ module Facter
         @log_level = :warn
         @show_legacy = true
         @ruby = true
-        @user_query = []
         @json = false
         @hocon = false
         @cache = true

data/lib/facter/framework/parsers/query_parser.rb

@@ -69,12 +69,19 @@ module Facter
         resolvable_fact_list = []
 
         loaded_fact_hash.each do |loaded_fact|
-          query_fact = query_tokens[query_token_range].join('.')
-
-          next unless found_fact?(loaded_fact.name, query_fact)
-
-          searched_fact = construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
-          resolvable_fact_list << searched_fact
+          # return the fact if toplevel namespace is found in the first query token
+          # eg. query: 'os.name' and loaded_fact_hash contains a fact with 'os' name
+          # it will construt and return the 'os' fact
+          if loaded_fact.name == query_tokens[0]
+            resolvable_fact_list = [construct_loaded_fact(query_tokens, query_token_range, loaded_fact)]
+          else
+            query_fact = query_tokens[query_token_range].join('.')
+
+            next unless found_fact?(loaded_fact.name, query_fact)
+
+            searched_fact = construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
+            resolvable_fact_list << searched_fact
+          end
         end
 
         @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}"

data/lib/facter/resolvers/az.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Az < BaseResolver
+      init_resolver
+
+      AZ_METADATA_URL = 'http://169.254.169.254/metadata/instance?api-version=2020-09-01'
+      AZ_SESSION_TIMEOUT = 5
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          log.debug('Querying Az metadata')
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = {}
+          data = get_data_from(AZ_METADATA_URL)
+          @fact_list[:metadata] = JSON.parse(data) unless data.empty?
+
+          @fact_list[fact_name]
+        end
+
+        def get_data_from(url)
+          headers = { Metadata: 'true' }
+          Facter::Util::Resolvers::Http.get_request(url, headers, { session: determine_session_timeout })
+        end
+
+        def determine_session_timeout
+          session_env = ENV['AZ_SESSION_TIMEOUT']
+          session_env ? session_env.to_i : AZ_SESSION_TIMEOUT
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/linux/hostname.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Hostname < BaseResolver
+        # :fqdn
+        # :domain
+        # :hostname
+
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+          end
+
+          def retrieve_info(fact_name)
+            require 'socket'
+            require 'facter/util/resolvers/ffi/hostname'
+
+            output = retrieving_hostname
+            return nil unless output
+
+            # Check if the gethostname method retrieved fqdn
+            hostname, domain = parse_fqdn(output)
+
+            fqdn = retrieve_fqdn_for_host(hostname) if hostname_and_no_domain?(hostname, domain)
+
+            _, domain = parse_fqdn(fqdn) if exists_and_valid_fqdn?(fqdn, hostname)
+
+            domain = read_domain unless exists_and_not_empty?(domain)
+
+            construct_fact_list(hostname, domain, fqdn)
+            @fact_list[fact_name]
+          end
+
+          def retrieving_hostname
+            output = Socket.gethostname
+            if !output || output.empty? || output['0.0.0.0']
+              output = Facter::Util::Resolvers::Ffi::Hostname.getffihostname
+            end
+
+            log.debug("Tried to retrieve hostname and got: #{output}")
+            output && !output.empty? ? output : nil
+          end
+
+          def parse_fqdn(output)
+            if output =~ /(.*?)\.(.+$)/
+              log.debug("Managed to read hostname: #{Regexp.last_match(1)} and domain: #{Regexp.last_match(2)}")
+              [Regexp.last_match(1), Regexp.last_match(2)]
+            else
+              log.debug("Only managed to read hostname: #{output}, no domain was found.")
+              [output, '']
+            end
+          end
+
+          def retrieve_fqdn_for_host(host)
+            begin
+              name = Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)[0]
+            rescue StandardError => e
+              log.debug("Socket.getaddrinfo failed to retrieve fqdn for hostname #{host} with: #{e}")
+            end
+
+            return name[2] if !name.nil? && !name.empty? && host != name[2] && name[2] != name[3]
+
+            retrieve_fqdn_for_host_with_ffi(host)
+          end
+
+          def retrieve_fqdn_for_host_with_ffi(host)
+            fqdn = Facter::Util::Resolvers::Ffi::Hostname.getffiaddrinfo(host)
+            log.debug("FFI getaddrinfo was called and it retrieved: #{fqdn}")
+            fqdn
+          end
+
+          def exists_and_valid_fqdn?(fqdn, hostname)
+            exists_and_not_empty?(fqdn) && fqdn.start_with?("#{hostname}.")
+          end
+
+          def hostname_and_no_domain?(hostname, domain)
+            domain.empty? && !hostname.empty?
+          end
+
+          def read_domain
+            file_content = Facter::Util::FileHelper.safe_read('/etc/resolv.conf')
+            if file_content =~ /^domain\s+(\S+)/
+              Regexp.last_match(1)
+            elsif file_content =~ /^search\s+(\S+)/
+              Regexp.last_match(1)
+            end
+          end
+
+          def construct_fqdn(host, domain, fqdn)
+            return fqdn if exists_and_not_empty?(fqdn)
+            return if host.nil? || host.empty?
+
+            exists_and_not_empty?(domain) ? "#{host}.#{domain}" : host
+          end
+
+          def construct_fact_list(hostname, domain, fqdn)
+            @fact_list[:hostname] = hostname
+            @fact_list[:domain] = domain
+            @fact_list[:fqdn] = construct_fqdn(@fact_list[:hostname], @fact_list[:domain], fqdn)
+          end
+
+          def exists_and_not_empty?(variable)
+            variable && !variable.empty?
+          end
+        end
+      end
+    end
+  end
+end