facter 4.0.28

data/lib/resolvers/open_vz.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OpenVz < BaseResolver
+      # build
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { check_proc_vz(fact_name) }
+        end
+
+        def check_proc_vz(fact_name)
+          if !Dir.exist?('/proc/vz') || !File.executable?('/proc/lve/list') || Dir.entries('/proc/vz').count.equal?(2)
+            return
+          end
+
+          @fact_list[:vm] = read_proc_status
+          @fact_list[fact_name]
+        end
+
+        def read_proc_status
+          proc_status_content = Facter::Util::FileHelper.safe_readlines('/proc/self/status', nil)
+          return unless proc_status_content
+
+          proc_status_content.each do |line|
+            parts = line.split("\s")
+            next unless parts.size.equal?(2)
+
+            next unless /^envID:/ =~ parts[0]
+
+            return 'openvzhn' if parts[1] == '0'
+
+            return 'openvzve'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/os_level_resolver.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OsLevel < BaseResolver
+      # build
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_oslevel(fact_name) }
+        end
+
+        def read_oslevel(fact_name)
+          output = Facter::Core::Execution.execute('/usr/bin/oslevel -s', logger: log)
+
+          @fact_list[:build] = output unless output.empty?
+          @fact_list[:kernel] = 'AIX'
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/os_release_resolver.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OsRelease < BaseResolver
+      # :pretty_name
+      # :name
+      # :version_id
+      # :version
+      # :id
+      # :id_like
+      # :ansi_color
+      # :home_url
+      # :support_url
+      # :bug_report_url
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_os_release_file(fact_name) }
+        end
+
+        def read_os_release_file(fact_name)
+          output = Util::FileHelper.safe_readlines('/etc/os-release')
+          return @fact_list[:name] = nil if output.empty?
+
+          pairs = []
+
+          output.each do |line|
+            pairs << line.strip.delete('"').split('=', 2)
+          end
+
+          fill_fact_list(pairs)
+          process_name
+          pad_version_id
+
+          @fact_list[fact_name]
+        end
+
+        def fill_fact_list(pairs)
+          result = Hash[*pairs.flatten]
+          result.each { |k, v| @fact_list[k.downcase.to_sym] = v }
+
+          @fact_list[:identifier] = @fact_list[:id]
+        end
+
+        def pad_version_id
+          @fact_list[:version_id] = "#{@fact_list[:version_id]}.0" unless @fact_list[:version_id] =~ /\./
+        end
+
+        def process_name
+          return unless @fact_list[:name]
+
+          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red')
+                                @fact_list[:name].split(' ')[0..1].join
+                              else
+                                @fact_list[:name].split(' ')[0].strip
+                              end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/partitions.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Partitions < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      BLOCK_PATH = '/sys/block'
+      BLOCK_SIZE = 512
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_partitions(fact_name) }
+        end
+
+        def read_partitions(fact_name)
+          @fact_list[:partitions] = {}
+          return {} unless File.readable?(BLOCK_PATH)
+
+          block_devices = Dir.entries(BLOCK_PATH).reject { |dir| dir =~ /^\.+/ }
+          block_devices.each do |block_device|
+            block_path = "#{BLOCK_PATH}/#{block_device}"
+            if File.directory?("#{block_path}/device")
+              extract_from_device(block_path)
+            elsif File.directory?("#{block_path}/dm")
+              extract_from_dm(block_path)
+            elsif File.directory?("#{block_path}/loop")
+              extract_from_loop(block_path)
+            end
+          end
+          @fact_list[fact_name]
+        end
+
+        def extract_from_device(block_path)
+          subdirs = browse_subdirectories(block_path)
+          subdirs.each do |subdir|
+            name = "/dev/#{subdir.split('/').last}"
+            populate_partitions(name, subdir)
+          end
+        end
+
+        def extract_from_dm(block_path)
+          map_name = Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
+          if map_name.empty?
+            populate_partitions("/dev#{block_path}", block_path)
+          else
+            populate_partitions("/dev/mapper/#{map_name}", block_path)
+          end
+        end
+
+        def extract_from_loop(block_path)
+          backing_file = Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
+          if backing_file.empty?
+            populate_partitions("/dev#{block_path}", block_path)
+          else
+            populate_partitions("/dev#{block_path}", block_path, backing_file)
+          end
+        end
+
+        def populate_partitions(partition_name, block_path, backing_file = nil)
+          @fact_list[:partitions][partition_name] = {}
+          size_bytes = Util::FileHelper.safe_read("#{block_path}/size", '0')
+                                       .chomp.to_i * BLOCK_SIZE
+          info_hash = { size_bytes: size_bytes,
+                        size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes),
+                        backing_file: backing_file }
+          info_hash.merge!(populate_from_blkid(partition_name))
+          @fact_list[:partitions][partition_name] = info_hash.reject { |_key, value| value.nil? }
+        end
+
+        def populate_from_blkid(partition_name)
+          return {} unless blkid_command?
+
+          @blkid_content ||= execute_and_extract_blkid_info
+          return {} unless @blkid_content[partition_name]
+
+          filesys = @blkid_content[partition_name]['TYPE']
+          uuid = @blkid_content[partition_name]['UUID']
+          label = @blkid_content[partition_name]['LABEL']
+          part_uuid = @blkid_content[partition_name]['PARTUUID']
+          part_label = @blkid_content[partition_name]['PARTLABEL']
+          { filesystem: filesys, uuid: uuid, label: label, partuuid: part_uuid, partlabel: part_label }
+        end
+
+        def blkid_command?
+          return @blkid_exists unless @blkid_exists.nil?
+
+          output = Facter::Core::Execution.execute('which blkid', logger: log)
+
+          @blkid_exists = !output.empty?
+        end
+
+        def execute_and_extract_blkid_info
+          stdout = Facter::Core::Execution.execute('blkid', logger: log)
+          output_hash = Hash[*stdout.split(/^([^:]+):/)[1..-1]]
+          output_hash.each do |key, value|
+            output_hash[key] = Hash[*value.delete('"').chomp.rstrip.split(/ ([^= ]+)=/)[1..-1]]
+          end
+        end
+
+        def browse_subdirectories(path)
+          dirs = Dir[File.join(path, '**', '*')].select { |p| File.directory? p }
+          dirs.select { |subdir| subdir.split('/').last.include?(path.split('/').last) }.reject(&:nil?)
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/path_resolver.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Path < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_path_from_env }
+        end
+
+        def read_path_from_env
+          @fact_list[:path] = ENV['PATH']
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/processors_resolver.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Processors < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          # :count
+          # :models
+          # :physical_count
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_cpuinfo(fact_name) }
+          end
+
+          def read_cpuinfo(fact_name)
+            cpuinfo_output = Util::FileHelper.safe_readlines('/proc/cpuinfo')
+            return if cpuinfo_output.empty?
+
+            read_processors(cpuinfo_output) # + model names
+
+            @fact_list[:physical_count] = @fact_list[:physical_processors].uniq.length
+            @fact_list[:physical_count] = physical_devices_count if @fact_list[:physical_count].zero?
+            @fact_list[fact_name]
+          end
+
+          def read_processors(cpuinfo_output)
+            @fact_list[:processors] = 0
+            @fact_list[:models] = []
+            @fact_list[:physical_processors] = []
+            cpuinfo_output.each do |line|
+              tokens = line.split(':')
+              count_processors(tokens)
+              construct_models_list(tokens)
+              count_physical_processors(tokens)
+            end
+          end
+
+          def count_processors(tokens)
+            @fact_list[:processors] += 1 if tokens.first.strip == 'processor'
+          end
+
+          def construct_models_list(tokens)
+            @fact_list[:models] << tokens.last.strip if tokens.first.strip == 'model name'
+          end
+
+          def count_physical_processors(tokens)
+            @fact_list[:physical_processors] << tokens.last.strip.to_i if tokens.first.strip == 'physical id'
+          end
+
+          def physical_devices_count
+            Dir.entries('/sys/devices/system/cpu').count { |dir| dir =~ /cpu[0-9]+$/ }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/puppet_version_resolver.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class PuppetVersionResolver < BaseResolver
+      # :puppetversion
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { puppet_version(fact_name) }
+        end
+
+        def puppet_version(fact_name)
+          require 'puppet/version'
+          @fact_list[:puppetversion] = Puppet.version
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/redhat_release_resolver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class RedHatRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_redhat_release(fact_name) }
+        end
+
+        def read_redhat_release(fact_name)
+          output = Util::FileHelper.safe_read('/etc/redhat-release', nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          build_fact_list(output)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(output)
+          output_strings = output.split('release')
+          output_strings.map!(&:strip)
+          version_codename = output_strings[1].split(' ')
+
+          @fact_list[:name] = name(output_strings[0])
+          @fact_list[:version] = version_codename[0].strip
+          codename = version_codename[1].strip
+          @fact_list[:codename] = codename.gsub(/[()]/, '')
+
+          @fact_list[:identifier] = identifier(@fact_list[:name])
+        end
+
+        def name(name)
+          name.strip.split(' ')[0..1].join
+        end
+
+        def identifier(name)
+          identifier = name.strip.downcase
+          identifier = 'rhel' if @fact_list[:name].strip.casecmp('Red Hat Enterprise Linux')
+
+          identifier
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/ruby_resolver.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Ruby < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_ruby_information(fact_name) }
+        end
+
+        def retrieve_ruby_information(fact_name)
+          @fact_list[:sitedir] = RbConfig::CONFIG['sitelibdir']
+          @fact_list[:platform] = RUBY_PLATFORM
+          @fact_list[:version] = RUBY_VERSION
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end