facter 4.0.32 → 4.0.37

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Memory < BaseResolver
+        BLOCKSIZE = 512
+        # :system
+        # :swap
+        @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}

@@ -8,15 +8,9 @@ module Facter
     module Solaris
       class Networking < BaseResolver
         @log = Facter::Log.new(self)
-        @semaphore = Mutex.new
         @fact_list ||= {}
         @interfaces = {}
 
-        BINDINGS_KEY = {
-          FFI::AF_INET => :bindings,
-          FFI::AF_INET6 => :bindings6
-        }.freeze
-
         class << self
           private
 
@@ -141,7 +135,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,43 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class OsRelease < BaseResolver
+        @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/processors.rb

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Solaris
       class Processors < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Zone < BaseResolver
+        @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,30 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class ZoneName < BaseResolver
+        @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/ssh_resolver.rb

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     class SshResolver < BaseResolver
       @log = Facter::Log.new(self)
-      @semaphore = Mutex.new
       @fact_list ||= {}
       @file_names = %w[ssh_host_rsa_key.pub ssh_host_dsa_key.pub ssh_host_ecdsa_key.pub ssh_host_ed25519_key.pub]
       @file_paths = %w[/etc/ssh /usr/local/etc/ssh /etc /usr/local/etc /etc/opt/ssh]

data/lib/facter/resolvers/suse_release_resolver.rb

@@ -7,7 +7,6 @@ module Facter
       # :version
       # :codename
 
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/sw_vers_resolver.rb

@@ -7,7 +7,6 @@ module Facter
       # :productversion
       # :buildversion
       #
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/timezone_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Timezone < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/uname_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Uname < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/uptime_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Uptime < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self
@@ -23,33 +22,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