facter 4.0.34 → 4.0.35

data/lib/facter/resolvers/networking_resolver.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Networking < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          primary_interface
+          interfaces_data
+          ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+          @fact_list[fact_name]
+        end
+
+        def primary_interface
+          result = Facter::Core::Execution.execute('route -n get default', logger: log)
+
+          @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
+        end
+
+        def interfaces_data
+          command_response = Facter::Core::Execution.execute('ifconfig -a', logger: log)
+
+          clean_up_interfaces_response(command_response)
+          parse_interfaces_response(command_response)
+        end
+
+        def clean_up_interfaces_response(response)
+          # convert ip ranges into single ip. eg. 10.16.132.213 -->  10.16.132.213 is converted to 10.16.132.213
+          response.gsub!(/(\d+(\.\d+)*)\s+-->\s+\d+(\.\d+)*/, '\\1')
+        end
+
+        def parse_interfaces_response(response)
+          parsed_interfaces_data = {}
+          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+
+          interfaces_data.each do |interface_name, raw_data|
+            parsed_interface_data = {}
+
+            extract_mtu(raw_data, parsed_interface_data)
+            extract_mac(raw_data, parsed_interface_data)
+            extract_dhcp(interface_name, raw_data, parsed_interface_data)
+            extract_ip_data(raw_data, parsed_interface_data)
+
+            parsed_interfaces_data[interface_name] = parsed_interface_data
+          end
+          @fact_list[:interfaces] = parsed_interfaces_data unless parsed_interfaces_data.empty?
+        end
+
+        def extract_mtu(raw_data, parsed_interface_data)
+          mtu = raw_data.match(/mtu\s+(\d+)/)&.captures&.first&.to_i
+          parsed_interface_data[:mtu] = mtu unless mtu.nil?
+        end
+
+        def extract_mac(raw_data, parsed_interface_data)
+          mac = raw_data.match(/(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/)&.captures&.first
+          parsed_interface_data[:mac] = mac unless mac.nil?
+        end
+
+        def extract_dhcp(interface_name, raw_data, parsed_interface_data)
+          return unless raw_data =~ /status:\s+active/
+
+          result = Facter::Core::Execution.execute("ipconfig getoption #{interface_name} " \
+                                                     'server_identifier', logger: log)
+
+          parsed_interface_data[:dhcp] = result.match(/^[\d.a-f:\s]+$/)&.to_s&.strip unless result.empty?
+        end
+
+        def extract_ip_data(raw_data, parsed_interface_data)
+          ip = extract_values(raw_data, /inet (\S+)/)
+          mask = extract_values(raw_data, /netmask (\S+)/).map { |val| val.hex.to_s(2).count('1') }
+
+          ip6 = extract_values(raw_data, /inet6 (\S+)/).map { |val| val.gsub(/%.+/, '') }
+          mask6 = extract_values(raw_data, /prefixlen (\S+)/)
+
+          parsed_interface_data[:bindings] = create_bindings(ip, mask) unless ip.empty?
+          parsed_interface_data[:bindings6] = create_bindings(ip6, mask6) unless ip6.empty?
+        end
+
+        def extract_values(data, regex)
+          results = []
+          data.scan(regex).flatten.each do |val|
+            results << val
+          end
+          results
+        end
+
+        def create_bindings(ips, masks)
+          bindings = []
+          ips.zip(masks).each do |ip, mask|
+            bindings << ::Resolvers::Utils::Networking.build_binding(ip, mask)
+          end
+          bindings
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/disks.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Disks < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_disks_info(fact_name) }
+          end
+
+          def read_disks_info(fact_name)
+            return unless File.executable?('/usr/bin/kstat')
+
+            log.debug('loading disks info')
+
+            kstat_output = Facter::Core::Execution.execute('/usr/bin/kstat sderr', logger: log)
+            return if kstat_output.empty?
+
+            @fact_list[fact_name] = parse(kstat_output)
+          end
+
+          def parse(kstat_output)
+            disks = {}
+
+            names = kstat_output.scan(/name:\s+(\w+)/).flatten
+            products = kstat_output.scan(/Product\s+(.+)/).flatten
+            vendors = kstat_output.scan(/Vendor\s+(\w+)/).flatten
+            sizes = kstat_output.scan(/Size\s+(\w+)/).flatten
+
+            names.each_with_index do |name, index|
+              disk_size = sizes[index].to_i
+              disks[name] = {
+                product: products[index],
+                size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(disk_size),
+                size_bytes: disk_size,
+                vendor: vendors[index]
+              }
+            end
+            disks
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/dmi.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Dmi < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          SMBIOS_PARAMS = {
+            'SMB_TYPE_BIOS' => {
+              bios_version: 'Version String: (.+)',
+              bios_vendor: 'Vendor: (.+)',
+              bios_release_date: 'Release Date: (.+)'
+            },
+            'SMB_TYPE_SYSTEM' => {
+              manufacturer: 'Manufacturer: (.+)',
+              product_name: 'Product: (.+)',
+              serial_number: 'Serial Number: (.+)',
+              product_uuid: 'UUID: (.+)'
+            },
+            'SMB_TYPE_CHASSIS' => {
+              chassis_asset_tag: 'Asset Tag: (.+)',
+              chassis_type: '(?:Chassis )?Type: (.+)'
+            }
+          }.freeze
+
+          def read_facts(fact_name)
+            param = SMBIOS_PARAMS.find { |_key, hash| hash[fact_name] }
+            return nil unless param
+
+            output = exec_smbios(param[0])
+            facts = param[1]
+            facts.each do |name, regx|
+              @fact_list[name] = output.match(/#{regx}/)&.captures&.first
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def exec_smbios(args)
+            return unless File.executable?('/usr/sbin/smbios')
+
+            Facter::Core::Execution.execute("/usr/sbin/smbios -t #{args}", logger: log)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/dmi_sparc.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class DmiSparc < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            output = exec_prtdiag
+            return unless output
+
+            matches = output.match(/System Configuration:\s+(.+?)\s+sun\d+\S+\s+(.+)/)&.captures
+
+            @fact_list[:manufacturer] = matches[0]&.strip
+            @fact_list[:product_name] = matches[1]&.strip
+
+            sneep = exec_sneep&.strip
+            @fact_list[:serial_number] = sneep
+
+            @fact_list[fact_name]
+          end
+
+          def exec_prtdiag
+            return unless File.executable?('/usr/sbin/prtdiag')
+
+            Facter::Core::Execution.execute('/usr/sbin/prtdiag', logger: log)
+          end
+
+          def exec_sneep
+            return unless File.executable?('/usr/sbin/sneep')
+
+            Facter::Core::Execution.execute('/usr/sbin/sneep', logger: log)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/os_release.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class OsRelease < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        @os_version_regex_patterns = ['Solaris \d+ \d+/\d+ s(\d+)[sx]?_u(\d+)wos_',
+                                      'Solaris (\d+)[.](\d+)', 'Solaris (\d+)']
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { build_release_facts(fact_name) }
+          end
+
+          def build_release_facts(fact_name)
+            result = Util::FileHelper.safe_read('/etc/release', nil)
+            return @fact_list[fact_name] = nil if result.nil?
+
+            @os_version_regex_patterns.each do |os_version_regex|
+              major, minor = search_for_os_version(/#{os_version_regex}/, result)
+              next unless major || minor
+
+              @fact_list[:major] = major
+              @fact_list[:minor] = minor
+              @fact_list[:full] = major == '10' ? major + '_u' + minor : major + '.' + minor
+              break
+            end
+            @fact_list[fact_name]
+          end
+
+          def search_for_os_version(regex_pattern, text)
+            result = text.match(regex_pattern)
+            major, minor = result.captures if result
+            minor = regex_pattern == /Solaris (\d+)/ ? '0' : minor
+            return [major, minor] if major && minor
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/zone.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Zone < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { build_zone_fact(fact_name) }
+          end
+
+          def build_zone_fact(fact_name)
+            command = '/usr/sbin/zoneadm list -cp'
+            zone_adm_output = Facter::Core::Execution.execute(command, logger: log)
+
+            if zone_adm_output.empty?
+              log.debug("Command #{command} returned an empty result")
+              return
+            end
+            @fact_list[:zone] = create_zone_facts(zone_adm_output)
+
+            @fact_list[fact_name]
+          end
+
+          def create_zone_facts(zones_result)
+            zones_fact = []
+            zones_result.each_line do |zone_line|
+              id, name, status, path, uuid, brand, ip_type = zone_line.split(':')
+              zones_fact << {
+                brand: brand,
+                id: id,
+                iptype: ip_type.chomp,
+                name: name,
+                uuid: uuid,
+                status: status,
+                path: path
+
+              }
+            end
+            zones_fact
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/zone_name.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class ZoneName < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { build_current_zone_name_fact(fact_name) }
+          end
+
+          def build_current_zone_name_fact(fact_name)
+            zone_name_output = Facter::Core::Execution.execute('/bin/zonename', logger: log)
+
+            if zone_name_output.empty?
+              log.debug("Command #{command} returned an empty result")
+              return
+            end
+            @fact_list[:current_zone_name] = zone_name_output.chomp
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/uptime_resolver.rb

@@ -23,33 +23,7 @@ module Facter
         def build_fact_list(seconds)
           return @fact_list[:uptime] = 'unknown' unless seconds
 
-          uptime_hash = create_uptime_hash(seconds)
-
-          @fact_list[:seconds] = uptime_hash[:seconds]
-          @fact_list[:hours]   = uptime_hash[:hours]
-          @fact_list[:days]    = uptime_hash[:days]
-          @fact_list[:uptime]  = uptime_hash[:uptime]
-        end
-
-        def create_uptime_hash(seconds)
-          results = {}
-          minutes = (seconds / 60) % 60
-
-          results[:seconds] = seconds
-          results[:hours]   = seconds / (60 * 60)
-          results[:days]    = results[:hours] / 24
-          results[:uptime]  = build_uptime_text(results[:days], results[:hours], minutes)
-
-          results
-        end
-
-        def build_uptime_text(days, hours, minutes)
-          case days
-          when 0 then "#{hours}:#{format('%<minutes>02d', minutes: minutes)} hours"
-          when 1 then '1 day'
-          else
-            "#{days} days"
-          end
+          @fact_list = Utils::UptimeHelper.create_uptime_hash(seconds)
         end
       end
     end

data/lib/facter/resolvers/utils/uptime_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Utils
+      module UptimeHelper
+        class << self
+          def create_uptime_hash(seconds)
+            results = {}
+            minutes = (seconds / 60) % 60
+
+            results[:seconds] = seconds
+            results[:hours]   = seconds / (60 * 60)
+            results[:days]    = results[:hours] / 24
+            results[:uptime]  = build_uptime_text(results[:days], results[:hours], minutes)
+
+            results
+          end
+
+          def build_uptime_text(days, hours, minutes)
+            case days
+            when 0 then "#{hours}:#{format('%<minutes>02d', minutes: minutes)} hours"
+            when 1 then '1 day'
+            else
+              "#{days} days"
+            end
+          end
+        end
+      end
+    end
+  end
+end