facter 4.0.32 → 4.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72f2204546c27a939b067c08cc85aaf8f38673a37db898cd9dda273e8047704c
-  data.tar.gz: 1815adc1638070582de416e8f7976a6ace992bd6e133077ab387e792b3f26415
+  metadata.gz: 32bb403fb4187d3a595b0b8aa4ed12ba472b1efc6d785cf2d371fc1488afd2d7
+  data.tar.gz: b8b159eedc00a4c17e2121e73f38bb76d383b298746731104511a36955ba382d
 SHA512:
-  metadata.gz: 6a7c95ea0a07b60e11aa33d1edf792c875139fa683ca2b30db252cad0b81e77a0ee2135f2237f0bb04e17b2df7f30705ace0c28a0e9f236459c717e6aa7f4010
-  data.tar.gz: fb8f00bc8f4a117d7d904125f6864296389257d2be4935d6492030570cd4100a333b190394a782f52ff0156fb9441b0a3228fda201048ede7c6e4f13ad28dd14
+  metadata.gz: 3a0f55015be59493c79b53f054e609a336d6e64385547534ffe62084b060d1b70da511f0a4d74179717bf8fe11287ed972586fb159c20a33d4832ba01f287ffc
+  data.tar.gz: 1814bfa9210ec33c2ddeafad6d123a4f2c7377c792cd4a494de5d467f606b46943f2a294c6abc4f1e1700a87edaeeffe3e1de0712782a46ada76ae289367e17f

data/lib/facter/facts/linux/virtual.rb

@@ -5,43 +5,59 @@ module Facts
     class Virtual
       FACT_NAME = 'virtual'
 
+      def initialize
+        @log = Facter::Log.new(self)
+      end
+
       def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        @log.debug('Linux Virtual Resolver')
+
         fact_value = check_docker_lxc || check_gce || retrieve_from_virt_what || check_vmware
         fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
 
+        @log.debug("Fact value is: #{fact_value}")
+
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       def check_gce
+        @log.debug('Checking GCE')
         bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
         'gce' if bios_vendor&.include?('Google')
       end
 
       def check_docker_lxc
+        @log.debug('Checking Docker and LXC')
         Facter::Resolvers::Containers.resolve(:vm)
       end
 
       def check_vmware
+        @log.debug('Checking VMware')
         Facter::Resolvers::Vmware.resolve(:vm)
       end
 
       def retrieve_from_virt_what
+        @log.debug('Checking virtual_what')
         Facter::Resolvers::VirtWhat.resolve(:vm)
       end
 
       def check_open_vz
+        @log.debug('Checking OpenVZ')
         Facter::Resolvers::OpenVz.resolve(:vm)
       end
 
       def check_vserver
+        @log.debug('Checking VServer')
         Facter::Resolvers::VirtWhat.resolve(:vserver)
       end
 
       def check_xen
+        @log.debug('Checking XEN')
         Facter::Resolvers::Xen.resolve(:vm)
       end
 
       def check_other_facts
+        @log.debug('Checking others')
         product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
         bios_vendor =  Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
         return 'kvm' if bios_vendor&.include?('Amazon EC2')
@@ -53,6 +69,7 @@ module Facts
       end
 
       def check_lspci
+        @log.debug('Checking lspci')
         Facter::Resolvers::Lspci.resolve(:vm)
       end
     end

data/lib/facter/facts/macosx/virtual.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'virtual'
 
       def call_the_resolver
-        fact_value = check_vmware || check_virtualbox || check_parallels
+        fact_value = check_vmware || check_virtualbox || check_parallels || 'physical'
 
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end

data/lib/facter/facts/solaris/memory/swap/available.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class Available
+          FACT_NAME = 'memory.swap.available'
+          ALIASES = 'swapfree'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/swap/available_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class AvailableBytes
+          FACT_NAME = 'memory.swap.available_bytes'
+          ALIASES = 'swapfree_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
+            fact_value = fact_value[:available_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/swap/capacity.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class Capacity
+          FACT_NAME = 'memory.swap.capacity'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
+            fact_value = fact_value[:capacity] if fact_value
+
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/swap/total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class Total
+          FACT_NAME = 'memory.swap.total'
+          ALIASES = 'swapsize'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/swap/total_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class TotalBytes
+          FACT_NAME = 'memory.swap.total_bytes'
+          ALIASES = 'swapsize_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
+            fact_value = fact_value[:total_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/swap/used.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class Used
+          FACT_NAME = 'memory.swap.used'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+            end
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/swap/used_bytes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class UsedBytes
+          FACT_NAME = 'memory.swap.used_bytes'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:swap)
+            fact_value = fact_value[:used_bytes] if fact_value
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/system/available.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class Available
+          FACT_NAME = 'memory.system.available'
+          ALIASES = 'memoryfree'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/system/available_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class AvailableBytes
+          FACT_NAME = 'memory.system.available_bytes'
+          ALIASES = 'memoryfree_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
+            fact_value = fact_value[:available_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/system/capacity.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class Capacity
+          FACT_NAME = 'memory.system.capacity'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
+            fact_value = fact_value[:capacity] if fact_value
+
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/system/total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class Total
+          FACT_NAME = 'memory.system.total'
+          ALIASES = 'memorysize'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/system/total_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class TotalBytes
+          FACT_NAME = 'memory.system.total_bytes'
+          ALIASES = 'memorysize_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
+            fact_value = fact_value[:total_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/system/used.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class Used
+          FACT_NAME = 'memory.system.used'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+            end
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/memory/system/used_bytes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class UsedBytes
+          FACT_NAME = 'memory.system.used_bytes'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::Memory.resolve(:system)
+            fact_value = fact_value[:used_bytes] if fact_value
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/lspci.rb

@@ -28,6 +28,8 @@ module Facter
 
         def retrieve_vm(output)
           output.each_line { |line| REGEX_VALUES.each { |key, value| return value if line =~ /#{key}/ } }
+
+          nil
         end
       end
     end

data/lib/facter/resolvers/networking_linux_resolver.rb

@@ -11,6 +11,7 @@ module Facter
         private
 
         def post_resolve(fact_name)
+          log.debug('in networking_linux_resolver')
           @fact_list.fetch(fact_name) { retrieve_network_info(fact_name) }
 
           @fact_list[fact_name]
@@ -36,12 +37,17 @@ module Facter
         end
 
         def retrieve_interface_info
+          log.debug('retrieve_interface_info')
           output = Facter::Core::Execution.execute('ip -o address', logger: log)
+          log.debug("ip -o address result is:\n#{output}")
+
           interfaces = {}
 
           output.each_line do |ip_line|
             ip_tokens = ip_line.split(' ')
 
+            log.debug("ip_tokens = #{ip_tokens}")
+            log.debug("interfaces = #{interfaces}")
             fill_ip_v4_info!(ip_tokens, interfaces)
             fill_io_v6_info!(ip_tokens, interfaces)
             find_dhcp!(ip_tokens, interfaces)
@@ -93,10 +99,15 @@ module Facter
         end
 
         def fill_ip_v4_info!(ip_tokens, network_info)
+          log.debug('fill_ip_v4_info!')
           return unless ip_tokens[2].casecmp('inet').zero?
 
           interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens)
 
+          log.debug("interface_name = #{interface_name}\n" \
+                      "ip4_address = #{ip4_address}\n" \
+                      "ip4_mask_length = #{ip4_mask_length}")
+
           binding = ::Resolvers::Utils::Networking.build_binding(ip4_address, ip4_mask_length)
           build_network_info_structure!(network_info, interface_name, :bindings)
 

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/utils/networking.rb

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

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'ipaddr'
-
 module Facter
   module Resolvers
     class Networking < BaseResolver

data/lib/facter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Facter
-  VERSION = '4.0.32' unless defined?(VERSION)
+  VERSION = '4.0.33' unless defined?(VERSION)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: facter
 version: !ruby/object:Gem::Version
-  version: 4.0.32
+  version: 4.0.33
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-30 00:00:00.000000000 Z
+date: 2020-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -565,6 +565,20 @@ files:
 - lib/facter/facts/solaris/kernelrelease.rb
 - lib/facter/facts/solaris/kernelversion.rb
 - lib/facter/facts/solaris/macaddress_interfaces.rb
+- lib/facter/facts/solaris/memory/swap/available.rb
+- lib/facter/facts/solaris/memory/swap/available_bytes.rb
+- lib/facter/facts/solaris/memory/swap/capacity.rb
+- lib/facter/facts/solaris/memory/swap/total.rb
+- lib/facter/facts/solaris/memory/swap/total_bytes.rb
+- lib/facter/facts/solaris/memory/swap/used.rb
+- lib/facter/facts/solaris/memory/swap/used_bytes.rb
+- lib/facter/facts/solaris/memory/system/available.rb
+- lib/facter/facts/solaris/memory/system/available_bytes.rb
+- lib/facter/facts/solaris/memory/system/capacity.rb
+- lib/facter/facts/solaris/memory/system/total.rb
+- lib/facter/facts/solaris/memory/system/total_bytes.rb
+- lib/facter/facts/solaris/memory/system/used.rb
+- lib/facter/facts/solaris/memory/system/used_bytes.rb
 - lib/facter/facts/solaris/mountpoints.rb
 - lib/facter/facts/solaris/mtu_interfaces.rb
 - lib/facter/facts/solaris/netmask6_interfaces.rb
@@ -808,6 +822,7 @@ files:
 - lib/facter/resolvers/solaris/ffi/structs.rb
 - lib/facter/resolvers/solaris/filesystems_resolver.rb
 - lib/facter/resolvers/solaris/ipaddress_resolver.rb
+- lib/facter/resolvers/solaris/memory.rb
 - lib/facter/resolvers/solaris/networking_resolver.rb
 - lib/facter/resolvers/solaris/processors.rb
 - lib/facter/resolvers/solaris/solaris_os_release_resolver.rb