facter 4.0.30 → 4.0.35

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/ffi/ffi.rb

@@ -20,6 +20,11 @@ module Facter
         INET_ADDRSTRLEN   = 16
         INET6_ADDRSTRLEN  = 46
       end
+
+      BINDINGS_KEY = {
+        FFI::AF_INET => :bindings,
+        FFI::AF_INET6 => :bindings6
+      }.freeze
     end
   end
 end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Memory < BaseResolver
+        BLOCKSIZE = 512
+        # :system
+        # :swap
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { calculate_memory(fact_name) }
+          end
+
+          def calculate_memory(fact_name)
+            @fact_list = { system: sys, swap: swap }
+
+            @fact_list[fact_name]
+          end
+
+          def sys
+            sys = {}
+            output = Facter::Core::Execution.execute('/usr/bin/kstat -m unix -n system_pages', logger: log).strip
+            total, free = parse_sys_output(output)
+
+            return unless total || free
+
+            sys[:total_bytes] = total
+            sys[:available_bytes] = free
+            sys[:used_bytes] = total - free
+            sys[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+
+            sys
+          end
+
+          def swap
+            swap_hash = {}
+            output = Facter::Core::Execution.execute('/usr/sbin/swap -l', logger: log).strip
+            total, free = parse_swap_output(output)
+
+            swap_hash[:total_bytes] = total
+            swap_hash[:available_bytes] = free
+            swap_hash[:used_bytes] = total - free
+            swap_hash[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+
+            swap_hash if total != 0
+          end
+
+          def parse_sys_output(output)
+            kstats = output.scan(/(physmem|pagesfree)\s+(\d+)/)
+            kstats = kstats.to_h
+            return unless kstats['physmem'] || kstats['pagesfree']
+            return unless pagesize != 0
+
+            total = kstats['physmem'].to_i * pagesize
+            free = kstats['pagesfree'].to_i * pagesize
+
+            [total, free]
+          end
+
+          def parse_swap_output(output)
+            total = 0
+            free = 0
+
+            output.each_line do |line|
+              swap_sizes = line.match(/(\d+)\s+(\d+)$/)
+              next if swap_sizes.nil?
+
+              total += swap_sizes[1].to_i
+              free += swap_sizes[2].to_i
+            end
+            total *= BLOCKSIZE
+            free *= BLOCKSIZE
+
+            [total, free]
+          end
+
+          def pagesize
+            unless @fact_list[:pagesize]
+              @fact_list[:pagesize] = Facter::Core::Execution.execute('pagesize', logger: log).strip.to_i
+              log.debug("Pagesize: #{@fact_list[:pagesize]}")
+            end
+            @fact_list[:pagesize]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/{networking_resolver.rb → networking.rb}

@@ -12,11 +12,6 @@ module Facter
         @fact_list ||= {}
         @interfaces = {}
 
-        BINDINGS_KEY = {
-          FFI::AF_INET => :bindings,
-          FFI::AF_INET6 => :bindings6
-        }.freeze
-
         class << self
           private
 
@@ -141,7 +136,8 @@ module Facter
           end
 
           def add_dhcp(interface_name)
-            result = Facter::Core::Execution.execute("dhcpinfo -i #{interface_name} ServerID", logger: log)
+            dhcpinfo_command = Facter::Core::Execution.which('dhcpinfo') || '/sbin/dhcpinfo'
+            result = Facter::Core::Execution.execute("#{dhcpinfo_command} -i #{interface_name} ServerID", logger: log)
 
             @interfaces[interface_name][:dhcp] = result.chomp
           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/ffi/load_averages.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Resolvers
+    module Utils
+      module Ffi
+        module LoadAverages
+          extend ::FFI::Library
+          ffi_lib ::FFI::Library::LIBC
+
+          attach_function :getloadavg, %i[pointer int], :int
+
+          def self.read_load_averages
+            raw_loadavg = ::FFI::MemoryPointer.new(:double, 3)
+
+            res = LoadAverages.getloadavg(raw_loadavg, 3)
+            return unless res == 3
+
+            raw_loadavg.read_array_of_double(res)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'ipaddr'
+
 module Resolvers
   module Utils
     module Networking

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

data/lib/facter/resolvers/windows/ffi/ffi.rb

@@ -30,7 +30,7 @@ module FFI
     def read_wide_string_with_length(char_length)
       # char_length is number of wide chars (typically excluding NULLs), *not* bytes
       str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
-      str.encode('UTF-8', str.encoding, {})
+      str.encode('UTF-8', str.encoding)
     end
 
     def read_wide_string_without_length

data/lib/facter/resolvers/windows/networking_resolver.rb

@@ -1,134 +1,134 @@
 # frozen_string_literal: true
 
-require 'ipaddr'
-
 module Facter
   module Resolvers
-    class Networking < BaseResolver
-      @log = Facter::Log.new(self)
-      @semaphore = Mutex.new
-      @fact_list ||= {}
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { read_network_information(fact_name) }
-        end
-
-        def read_network_information(fact_name)
-          require 'facter/resolvers/windows/ffi/networking_ffi'
+    module Windows
+      class Networking < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_network_information(fact_name) }
+          end
 
-          size_ptr = FFI::MemoryPointer.new(NetworkingFFI::BUFFER_LENGTH)
-          adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
-          flags = NetworkingFFI::GAA_FLAG_SKIP_ANYCAST |
-                  NetworkingFFI::GAA_FLAG_SKIP_MULTICAST | NetworkingFFI::GAA_FLAG_SKIP_DNS_SERVER
+          def read_network_information(fact_name)
+            require 'facter/resolvers/windows/ffi/networking_ffi'
 
-          return unless (adapter_addresses = get_adapter_addresses(size_ptr, adapter_addresses, flags))
+            size_ptr = FFI::MemoryPointer.new(NetworkingFFI::BUFFER_LENGTH)
+            adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
+            flags = NetworkingFFI::GAA_FLAG_SKIP_ANYCAST |
+                    NetworkingFFI::GAA_FLAG_SKIP_MULTICAST | NetworkingFFI::GAA_FLAG_SKIP_DNS_SERVER
 
-          iterate_list(adapter_addresses)
+            return unless (adapter_addresses = get_adapter_addresses(size_ptr, adapter_addresses, flags))
 
-          ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+            iterate_list(adapter_addresses)
 
-          @fact_list[fact_name]
-        end
+            ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
 
-        def get_adapter_addresses(size_ptr, adapter_addresses, flags)
-          error = nil
-          3.times do
-            error = NetworkingFFI::GetAdaptersAddresses(NetworkingFFI::AF_UNSPEC, flags,
-                                                        FFI::Pointer::NULL, adapter_addresses, size_ptr)
-            break if error == NetworkingFFI::ERROR_SUCCES
-
-            if error == NetworkingFFI::ERROR_BUFFER_OVERFLOW
-              adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
-            else
-              @log.debug 'Unable to retrieve networking facts!'
-              return nil
-            end
+            @fact_list[fact_name]
           end
-          return nil unless error.zero?
 
-          adapter_addresses
-        end
+          def get_adapter_addresses(size_ptr, adapter_addresses, flags)
+            error = nil
+            3.times do
+              error = NetworkingFFI::GetAdaptersAddresses(NetworkingFFI::AF_UNSPEC, flags,
+                                                          FFI::Pointer::NULL, adapter_addresses, size_ptr)
+              break if error == NetworkingFFI::ERROR_SUCCES
+
+              if error == NetworkingFFI::ERROR_BUFFER_OVERFLOW
+                adapter_addresses = FFI::MemoryPointer.new(IpAdapterAddressesLh.size, NetworkingFFI::BUFFER_LENGTH)
+              else
+                @log.debug 'Unable to retrieve networking facts!'
+                return nil
+              end
+            end
+            return nil unless error.zero?
 
-        def adapter_down?(adapter)
-          adapter[:OperStatus] != NetworkingFFI::IF_OPER_STATUS_UP ||
-            ![NetworkingFFI::IF_TYPE_ETHERNET_CSMACD, NetworkingFFI::IF_TYPE_IEEE80211].include?(adapter[:IfType])
-        end
+            adapter_addresses
+          end
 
-        def retrieve_dhcp_server(adapter)
-          if !(adapter[:Flags] & NetworkingFFI::IP_ADAPTER_DHCP_ENABLED).zero? &&
-             adapter[:Union][:Struct][:Length] >= IpAdapterAddressesLh.size
-            NetworkUtils.address_to_string(adapter[:Dhcpv4Server])
+          def adapter_down?(adapter)
+            adapter[:OperStatus] != NetworkingFFI::IF_OPER_STATUS_UP ||
+              ![NetworkingFFI::IF_TYPE_ETHERNET_CSMACD, NetworkingFFI::IF_TYPE_IEEE80211].include?(adapter[:IfType])
           end
-        end
 
-        def iterate_list(adapter_addresses)
-          net_interface = {}
-          IpAdapterAddressesLh.read_list(adapter_addresses) do |adapter_address|
-            if adapter_down?(adapter_address)
-              adapter_address = IpAdapterAddressesLh.new(adapter_address[:Next])
-              next
+          def retrieve_dhcp_server(adapter)
+            if !(adapter[:Flags] & NetworkingFFI::IP_ADAPTER_DHCP_ENABLED).zero? &&
+               adapter[:Union][:Struct][:Length] >= IpAdapterAddressesLh.size
+              NetworkUtils.address_to_string(adapter[:Dhcpv4Server])
             end
-            @fact_list[:domain] ||= adapter_address[:DnsSuffix].read_wide_string_without_length
-            name = adapter_address[:FriendlyName].read_wide_string_without_length
-            net_interface[name] = build_interface_info(adapter_address, name)
           end
 
-          @fact_list[:interfaces] = net_interface unless net_interface.empty?
-        end
+          def iterate_list(adapter_addresses)
+            net_interface = {}
+            IpAdapterAddressesLh.read_list(adapter_addresses) do |adapter_address|
+              if adapter_down?(adapter_address)
+                adapter_address = IpAdapterAddressesLh.new(adapter_address[:Next])
+                next
+              end
+              @fact_list[:domain] ||= adapter_address[:DnsSuffix].read_wide_string_without_length
+              name = adapter_address[:FriendlyName].read_wide_string_without_length
+              net_interface[name] = build_interface_info(adapter_address, name)
+            end
 
-        def build_interface_info(adapter_address, name)
-          hash = {}
+            @fact_list[:interfaces] = net_interface unless net_interface.empty?
+          end
 
-          hash[:dhcp] = retrieve_dhcp_server(adapter_address)
-          hash[:mtu] = adapter_address[:Mtu]
+          def build_interface_info(adapter_address, name)
+            hash = {}
 
-          bindings = find_ip_addresses(adapter_address[:FirstUnicastAddress], name)
-          hash[:bindings] = bindings[:ipv4] unless bindings[:ipv4].empty?
-          hash[:bindings6] = bindings[:ipv6] unless bindings[:ipv6].empty?
-          hash[:mac] = NetworkUtils.find_mac_address(adapter_address)
-          hash
-        end
+            hash[:dhcp] = retrieve_dhcp_server(adapter_address)
+            hash[:mtu] = adapter_address[:Mtu]
 
-        def find_ip_addresses(unicast_addresses, name)
-          bindings = {}
-          bindings[:ipv6] = []
-          bindings[:ipv4] = []
+            bindings = find_ip_addresses(adapter_address[:FirstUnicastAddress], name)
+            hash[:bindings] = bindings[:ipv4] unless bindings[:ipv4].empty?
+            hash[:bindings6] = bindings[:ipv6] unless bindings[:ipv6].empty?
+            hash[:mac] = NetworkUtils.find_mac_address(adapter_address)
+            hash
+          end
 
-          IpAdapterUnicastAddressLH.read_list(unicast_addresses) do |unicast|
-            addr = NetworkUtils.address_to_string(unicast[:Address])
-            unless addr
-              unicast = IpAdapterUnicastAddressLH.new(unicast[:Next])
-              next
+          def find_ip_addresses(unicast_addresses, name)
+            bindings = {}
+            bindings[:ipv6] = []
+            bindings[:ipv4] = []
+
+            IpAdapterUnicastAddressLH.read_list(unicast_addresses) do |unicast|
+              addr = NetworkUtils.address_to_string(unicast[:Address])
+              unless addr
+                unicast = IpAdapterUnicastAddressLH.new(unicast[:Next])
+                next
+              end
+
+              sock_addr = SockAddr.new(unicast[:Address][:lpSockaddr])
+              add_ip_data(addr, unicast, sock_addr, bindings)
+              find_primary_interface(sock_addr, name, addr)
             end
-
-            sock_addr = SockAddr.new(unicast[:Address][:lpSockaddr])
-            add_ip_data(addr, unicast, sock_addr, bindings)
-            find_primary_interface(sock_addr, name, addr)
+            bindings
           end
-          bindings
-        end
 
-        def add_ip_data(addr, unicast, sock_addr, bindings)
-          result = find_bindings(sock_addr, unicast, addr)
-          return unless result
+          def add_ip_data(addr, unicast, sock_addr, bindings)
+            result = find_bindings(sock_addr, unicast, addr)
+            return unless result
 
-          bindings[:ipv6] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET6
-          bindings[:ipv4] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET
-        end
+            bindings[:ipv6] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET6
+            bindings[:ipv4] << result if sock_addr[:sa_family] == NetworkingFFI::AF_INET
+          end
 
-        def find_bindings(sock_addr, unicast, addr)
-          return unless [NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family])
+          def find_bindings(sock_addr, unicast, addr)
+            return unless [NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family])
 
-          ::Resolvers::Utils::Networking.build_binding(addr, unicast[:OnLinkPrefixLength])
-        end
+            ::Resolvers::Utils::Networking.build_binding(addr, unicast[:OnLinkPrefixLength])
+          end
 
-        def find_primary_interface(sock_addr, name, addr)
-          if !@fact_list[:primary_interface] &&
-             ([NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family]) &&
-                 !::Resolvers::Utils::Networking.ignored_ip_address(addr))
-            @fact_list[:primary_interface] = name.to_s
+          def find_primary_interface(sock_addr, name, addr)
+            if !@fact_list[:primary_interface] &&
+               ([NetworkingFFI::AF_INET, NetworkingFFI::AF_INET6].include?(sock_addr[:sa_family]) &&
+               !::Resolvers::Utils::Networking.ignored_ip_address(addr))
+              @fact_list[:primary_interface] = name.to_s
+            end
           end
         end
       end