facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/lib/resolvers/aix/architecture_resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Architecture < BaseResolver
+      # :architecture
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_architecture(fact_name) }
+        end
+
+        def read_architecture(fact_name)
+          require_relative 'utils/odm_query'
+          odmquery = ODMQuery.new
+          odmquery
+            .equals('name', 'proc0')
+            .equals('attribute', 'type')
+
+          result = odmquery.execute
+
+          return unless result
+
+          result.each_line do |line|
+            if line.include?('value')
+              @fact_list[:architecture] = line.split('=')[1].strip.delete('\"')
+              break
+            end
+          end
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/ffi/ffi_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Aix
+    module FfiHelper
+      KINFO_GET_AVENRUN = 1
+      KINFO_READ        = 8 << 8
+
+      module Libc
+        extend FFI::Library
+
+        RTLD_LAZY   = 0x00000004
+        RTLD_GLOBAL = 0x00010000
+        RTLD_MEMBER = 0x00040000
+
+        @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
+        ffi_lib 'libc.a(shr.o)'
+
+        attach_function :getkerninfo, %i[int pointer pointer int], :int
+      end
+
+      def self.read_load_averages
+        averages = FFI::MemoryPointer.new(:long_long, 3)
+        averages_size = FFI::MemoryPointer.new(:int, 1)
+        averages_size.write_int(averages.size)
+
+        return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+
+        averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+      end
+    end
+  end
+end

data/lib/resolvers/aix/hardware_resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Hardware < BaseResolver
+      # :hardware
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_hardware(fact_name) }
+        end
+
+        def read_hardware(fact_name)
+          require_relative 'utils/odm_query'
+          odmquery = Facter::ODMQuery.new
+          odmquery
+            .equals('name', 'sys0')
+            .equals('attribute', 'modelname')
+
+          result = odmquery.execute
+
+          return unless result
+
+          result.each_line do |line|
+            if line.include?('value')
+              @fact_list[:hardware] = line.split('=')[1].strip.delete('\"')
+              break
+            end
+          end
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/load_averages_resolver.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      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] = {}.tap do |h|
+              h['1m'], h['5m'], h['15m'] = Facter::Aix::FfiHelper.read_load_averages
+            end
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/networking_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Networking < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_netstat(fact_name) }
+          end
+
+          def read_netstat(fact_name)
+            output, _status = Open3.capture2('netstat -rn')
+            output = output.split("\n").select { |line| (line =~ /\s\s[0-9]+.[0-9]+.[0-9]+.[0-9]+|\s\s.*:[0-9a-f]+/) }
+            get_primary_interface_info(output)
+
+            @fact_list[fact_name]
+          end
+
+          def get_primary_interface_info(output)
+            primary_interface_info = output.select { |line| line =~ /=>/ }.first.split(' ')
+            @fact_list[:primary] = primary_interface_info[5]
+            @fact_list[:ip] = primary_interface_info[1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/os_level_resolver.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OsLevel < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_oslevel(fact_name) }
+        end
+
+        def read_oslevel(fact_name)
+          output, _status = Open3.capture2('/usr/bin/oslevel -s 2>/dev/null')
+          @fact_list[:build] = output
+          @fact_list[:kernel] = 'AIX'
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/utils/odm_query.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# CuAt (Customized Attributes) non-default attribute values
+# CuDv (Customized Devices) the devices present on this machine
+# PdAt (Predefined Attributes) default values for all device attributes
+# PdDv (Predefined Devices) the list of all devices supported by this release of AIX
+
+module Facter
+  class ODMQuery
+    REPOS = %w[CuAt CuDv PdAt PdDv].freeze
+
+    def initialize
+      @query = ''
+      @conditions = []
+    end
+
+    def equals(field, value)
+      @conditions << "#{field}='#{value}'"
+      self
+    end
+
+    def like(field, value)
+      @conditions << "#{field} like '#{value}'"
+      self
+    end
+
+    def execute
+      result = nil
+      REPOS.each do |repo|
+        break if result
+
+        result, _s = Open3.capture2("#{query} #{repo}")
+      end
+      result
+    end
+
+    def query
+      'odmget -q "' + @conditions.join(' AND ') + '"'
+    end
+  end
+end

data/lib/resolvers/augeas_resolver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Augeas < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_augeas_version(fact_name) }
+        end
+
+        def read_augeas_version(fact_name)
+          output, _status = Open3.capture2('augparse --version 2>&1')
+          @fact_list[:augeas_version] = Regexp.last_match(1) if output =~ /^augparse (\d+\.\d+\.\d+)/
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/base_resolver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class BaseResolver
+      def self.log
+        @log ||= Log.new(self)
+      end
+
+      def self.invalidate_cache
+        @fact_list = {}
+      end
+
+      def self.subscribe_to_manager
+        Facter::CacheManager.subscribe(self)
+      end
+
+      def self.resolve(fact_name)
+        @semaphore.synchronize do
+          subscribe_to_manager
+          post_resolve(fact_name)
+        end
+      rescue LoadError => e
+        log.error("resolving fact #{fact_name}, but #{e}")
+        @fact_list[fact_name] = nil
+      end
+
+      def self.post_resolve(_fact_name)
+        raise NotImplementedError, "You must implement post_resolve(fact_name) method in #{name}"
+      end
+    end
+  end
+end

data/lib/resolvers/debian_version_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DebianVersion < BaseResolver
+      # :major
+      # :minor
+      # :full
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_debian_version(fact_name) }
+        end
+
+        def read_debian_version(fact_name)
+          output, _status = Open3.capture2('cat /etc/debian_version')
+          full_version = output.delete("\n")
+          versions = full_version.split('.')
+
+          @fact_list[:full] = full_version
+          @fact_list[:major] = versions[0]
+          @fact_list[:minor] = versions[1].gsub(/^0([1-9])/, '\1')
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/disk_resolver.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Disk < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        DIR = '/sys/block'
+        FILE_PATHS = { model: 'device/model', size: 'size', vendor: 'device/vendor' }.freeze
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            @fact_list[:disks] = {}
+            build_disks_hash
+
+            FILE_PATHS.each do |key, file|
+              @fact_list[:disks].each do |disk, value|
+                file_path = File.join(DIR, disk, file)
+
+                next unless File.exist?(file_path)
+
+                result = File.read(file_path).strip
+
+                # Linux always considers sectors to be 512 bytes long independently of the devices real block size.
+                value[key] = file =~ /size/ ? result.to_i * 512 : result
+              end
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def build_disks_hash
+            directories = Dir.entries(DIR).reject { |dir| dir =~ /\.+/ }
+            directories.each { |disk| @fact_list[:disks].merge!(disk => {}) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/dmi_resolver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class DmiBios < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          # :bios_vendor
+          # :bios_date
+          # :bios_version
+          # :board_vendor
+          # :board_serial
+          # :board_name
+          # :chassis_asset_tag
+          # :chassis_type
+          # :sys_vendor
+          # :product_serial
+          # :product_name
+          # :product_uuid
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          # File.read("/sys/class/dmi/id/#{file}")
+          def read_facts(fact_name)
+            files = %w[bios_date bios_vendor bios_version board_vendor board_name board_serial
+                       chassis_asset_tag chassis_type sys_vendor product_name product_serial
+                       product_uuid]
+            return unless File.directory?('/sys/class/dmi')
+
+            if files.include?(fact_name.to_s) && File.exist?("/sys/class/dmi/id/#{fact_name}")
+              @fact_list[fact_name] = File.read("/sys/class/dmi/id/#{fact_name}").strip
+              chassis_to_name(@fact_list[fact_name]) if fact_name == :chassis_type
+
+            end
+            @fact_list[fact_name]
+          end
+
+          def chassis_to_name(chassis_type)
+            types = ['Other', nil, 'Desktop', 'Low Profile Desktop', 'Pizza Box', 'Mini Tower', 'Tower',
+                     'Portable', 'Laptop', 'Notebook', 'Hand Held', 'Docking Station', 'All in One', 'Sub Notebook',
+                     'Space-Saving', 'Lunch Box', 'Main System Chassis', 'Expansion Chassis', 'SubChassis',
+                     'Bus Expansion Chassis', 'Peripheral Chassis', 'Storage Chassis', 'Rack Mount Chassis',
+                     'Sealed-Case PC', 'Multi-system', 'CompactPCI', 'AdvancedTCA', 'Blade', 'Blade Enclosure',
+                     'Tablet', 'Convertible', 'Detachable']
+            @fact_list[:chassis_type] = types[chassis_type.to_i - 1]
+          end
+        end
+      end
+    end
+  end
+end