facter 4.0.31 → 4.0.36

data/lib/facter/facts/freebsd/solaris_zones/current.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Facts
-  module Freebsd
-    module SolarisZones
-      class Current
-        FACT_NAME = 'solaris_zones.current'
-
-        def call_the_resolver
-          []
-        end
-      end
-    end
-  end
-end

data/lib/facter/facts/freebsd/solaris_zones/zone.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Facts
-  module Freebsd
-    module SolarisZones
-      class Zone
-        FACT_NAME = 'solaris_zones.zones'
-
-        def call_the_resolver
-          []
-        end
-      end
-    end
-  end
-end

data/lib/facter/facts/solaris/solaris_zones/zone.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Facts
-  module Solaris
-    module SolarisZones
-      class Zone
-        FACT_NAME = 'solaris_zones.zones'
-        ALIASES = %w[
-          zone_.*_brand
-          zone_.*_iptype
-          zone_.*_name
-          zone_.*_uuid
-          zone_.*_id
-          zone_.*_path
-          zone_.*_status
-          zones
-        ].freeze
-
-        def call_the_resolver
-          resolved_facts = []
-          zones = {}
-
-          results = Facter::Resolvers::SolarisZone.resolve(:zone)
-          return Facter::ResolvedFact.new(FACT_NAME, nil) unless results
-
-          results&.each do |result|
-            zones.merge!(parse_result(result))
-            resolved_facts << create_legacy_zone_facts(result)
-          end
-
-          resolved_facts << Facter::ResolvedFact.new('solaris_zones.zones', zones)
-          resolved_facts << Facter::ResolvedFact.new('zones', results.count, :legacy)
-
-          resolved_facts.flatten
-        end
-
-        private
-
-        def parse_result(result)
-          {
-            result[:name].to_sym => {
-              brand: result[:brand],
-              id: result[:id],
-              ip_type: result[:iptype],
-              path: result[:path],
-              status: result[:status]
-            }
-          }
-        end
-
-        def create_legacy_zone_facts(zone)
-          legacy_facts = []
-          %w[brand iptype name uuid id path status].each do |key|
-            legacy_facts << Facter::ResolvedFact.new("zone_#{zone[:name]}_#{key}", zone[key.to_sym], :legacy)
-          end
-
-          legacy_facts
-        end
-      end
-    end
-  end
-end

data/lib/facter/resolvers/bsd/load_averages_resolver.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    module Bsd
-      class LoadAverages < BaseResolver
-        @semaphore = Mutex.new
-        @fact_list ||= {}
-        class << self
-          private
-
-          def post_resolve(fact_name)
-            @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
-          end
-
-          def read_load_averages(fact_name)
-            require_relative 'ffi/ffi_helper'
-            @fact_list[:load_averages] = %w[1m 5m 15m].zip(Facter::Bsd::FfiHelper.read_load_averages).to_h
-
-            @fact_list[fact_name]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    module Macosx
-      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
-end

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

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class SolarisRelease < 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

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class SolarisZoneName < 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

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    module Solaris
-      class ZFS < BaseResolver
-        @semaphore = Mutex.new
-        @fact_list ||= {}
-        class << self
-          private
-
-          def post_resolve(fact_name)
-            @fact_list.fetch(fact_name) { zfs_fact(fact_name) }
-          end
-
-          def zfs_fact(fact_name)
-            build_zfs_facts
-            @fact_list[fact_name]
-          end
-
-          def build_zfs_facts
-            output = Facter::Core::Execution.execute('zfs upgrade -v', logger: log)
-            features_list = output.scan(/^\s+(\d+)/).flatten
-
-            return if features_list.empty?
-
-            @fact_list[:zfs_featurenumbers] = features_list.join(',')
-            @fact_list[:zfs_version] = features_list.last
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class SolarisZone < 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

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    module Solaris
-      class ZPool < BaseResolver
-        @semaphore = Mutex.new
-        @fact_list ||= {}
-        class << self
-          private
-
-          def post_resolve(fact_name)
-            @fact_list.fetch(fact_name) { zpool_fact(fact_name) }
-          end
-
-          def zpool_fact(fact_name)
-            build_zpool_facts
-            @fact_list[fact_name]
-          end
-
-          def build_zpool_facts
-            output = Facter::Core::Execution.execute('zpool upgrade -v', logger: log)
-            features_list = output.scan(/^\s+(\d+)/).flatten
-            features_flags = output.scan(/^([a-z0-9_]+)[[:blank:]]*(\(read-only compatible\))?$/).map(&:first)
-
-            return if features_list.empty?
-
-            @fact_list[:zpool_featurenumbers] = features_list.join(',')
-            @fact_list[:zpool_featureflags] = features_flags.join(',')
-            @fact_list[:zpool_version] = features_flags.any? ? '5000' : features_list.last
-          end
-        end
-      end
-    end
-  end
-end