facter 4.0.31 → 4.0.36

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Utils
+      module Http
+        @log = Facter::Log.new(self)
+
+        class << self
+          CONNECTION_TIMEOUT = 0.6
+          SESSION_TIMEOUT = 5
+
+          # Makes a GET http request and returns it's response.
+          #
+          # Params:
+          # url: String which contains the address to which the request will be made
+          # headers: Hash which contains the headers you need to add to your request.
+          #          Default headers is an empty hash
+          #          Example: { "Accept": 'application/json' }
+          # timeouts: Hash that includes the values for the session and connection timeouts.
+          #          Example: { session: 2.4. connection: 5 }
+          #
+          # Return value:
+          # is a string with the response body if the response code is 200.
+          # If the response code is not 200, an empty string is returned.
+          def get_request(url, headers = {}, timeouts = {})
+            make_request(url, headers, timeouts, 'GET')
+          end
+
+          private
+
+          def make_request(url, headers, timeouts, request_type)
+            require 'net/http'
+
+            uri = URI.parse(url)
+            http = http_obj(uri, timeouts)
+            request = request_obj(headers, uri, request_type)
+
+            # Make the request
+            resp = http.request(request)
+            response_code_valid?(resp.code.to_i) ? resp.body : ''
+          rescue StandardError => e
+            @log.debug("Trying to connect to #{url} but got: #{e.message}")
+            ''
+          end
+
+          def http_obj(parsed_url, timeouts)
+            http = Net::HTTP.new(parsed_url.host)
+            http.read_timeout = timeouts[:session] || SESSION_TIMEOUT
+            http.open_timeout = timeouts[:connection] || CONNECTION_TIMEOUT
+            http
+          end
+
+          def request_obj(headers, parsed_url, request_type)
+            return Net::HTTP::Get.new(parsed_url.request_uri, headers) if request_type == 'GET'
+
+            raise StandardError("Unknown http request type: #{request_type}")
+          end
+
+          def response_code_valid?(http_code)
+            @log.debug("Request failed with error code #{http_code}") unless http_code.equal?(200)
+            http_code.equal?(200)
+          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