facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/lib/resolvers/windows/virtualization_resolver.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Virtualization < BaseResolver
+      @log = Facter::Log.new(self)
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        # Virtual
+        # Is_Virtual
+
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
+        end
+
+        def read_fact_from_computer_system(fact_name)
+          win = Win32Ole.new
+          comp = win.exec_query('SELECT Manufacturer,Model,OEMStringArray FROM Win32_ComputerSystem')
+          unless comp
+            @log.debug 'WMI query returned no results for Win32_ComputerSystem with values'\
+            ' Manufacturer, Model and OEMStringArray.'
+            return
+          end
+
+          build_fact_list(comp)
+          @fact_list[fact_name]
+        end
+
+        def determine_hypervisor_by_model(comp)
+          model_hash = { 'VirtualBox' => 'virtualbox', 'VMware' => 'vmware', 'KVM' => 'kvm',
+                         'Bochs' => 'bochs', 'Google' => 'gce', 'OpenStack' => 'openstack' }
+          model_hash[model_hash.keys.find { |key| comp.Model =~ /^#{key}/ }]
+        end
+
+        def determine_hypervisor_by_manufacturer(comp)
+          manufacturer = comp.Manufacturer
+          if comp.Model =~ /^Virtual Machine/ && manufacturer =~ /^Microsoft/
+            'hyperv'
+          elsif manufacturer =~ /^Xen/
+            'xen'
+          elsif manufacturer =~ /^Amazon EC2/
+            'kvm'
+          else
+            'physical'
+          end
+        end
+
+        def build_fact_list(comp)
+          @fact_list[:oem_strings] = []
+          @fact_list[:oem_strings] += comp.to_enum.map(&:OEMStringArray).flatten
+
+          comp = comp.to_enum.first
+          hypervisor = determine_hypervisor_by_model(comp) || determine_hypervisor_by_manufacturer(comp)
+
+          @fact_list[:virtual] = hypervisor
+          @fact_list[:is_virtual] = (!hypervisor.include?('physical')).to_s
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/win_os_description_resolver.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class WinOsDescription < 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_from_ole(fact_name) }
+        end
+
+        def read_from_ole(fact_name)
+          win = Win32Ole.new
+          op_sys = win.return_first('SELECT ProductType,OtherTypeDescription FROM Win32_OperatingSystem')
+          unless op_sys
+            @log.debug 'WMI query returned no results for Win32_OperatingSystem'\
+                       'with values ProductType and OtherTypeDescription.'
+            return
+          end
+          @fact_list[:consumerrel] = (op_sys.ProductType == 1)
+          @fact_list[:description] = op_sys.OtherTypeDescription
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/wpar_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Wpar < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_wpar(fact_name) }
+        end
+
+        def read_wpar(fact_name)
+          lpar_cmd = '/usr/bin/lparstat -W 2>/dev/null'
+          output, status = Open3.capture2(lpar_cmd)
+          return nil unless status.success?
+
+          output.each_line do |line|
+            populate_wpar_data(line.split(':').map(&:strip))
+          end
+          @fact_list[fact_name]
+        end
+
+        def populate_wpar_data(key_value)
+          @fact_list[:wpar_key]              = key_value[1].to_i if key_value[0] == 'WPAR Key'
+          @fact_list[:wpar_configured_id]    = key_value[1].to_i if key_value[0] == 'WPAR Configured ID'
+        end
+      end
+    end
+  end
+end

data/lib/util/fact.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# This class represents a fact. Each fact has a name and multiple
+# {Facter::Util::Resolution resolutions}.
+#
+# Create facts using {Facter.add}
+#
+# @api public
+module Facter
+  module Util
+    class Fact < LegacyFacter::Util::Fact
+    end
+  end
+end

data/tasks/create_fact.rake

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+desc 'Create a fact template for the specified arguments'
+task :create_fact, [:os, :fact_name] do |_, args|
+  require_relative 'fact_generator/fact_creator'
+
+  abort 'Usage: rake \'create_facts[os,fact_name]\'' if !args[:os] || !args[:fact_name]
+
+  fact_creator = FactCreator.new
+  fact_creator.create_fact(args[:os], args[:fact_name])
+end
+
+desc 'Create one or multiple facts by reading descriptions from facts.json'
+task :create_facts do
+  require_relative 'fact_generator/fact_creator'
+
+  fact_creator = FactCreator.new
+  fact_creator.create_facts
+end

data/tasks/fact_generator/fact.erb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facter
+  module <%= os_name %>
+    class <%= camelcase_fact_name %>
+      FACT_NAME = '<%= fact_name %>'
+
+      def call_the_resolver
+        fact_value = 'should call a resolver'
+        ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

data/tasks/fact_generator/fact_creator.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+require 'fileutils'
+require 'erb'
+
+ROOT_DIR = Pathname.new(File.expand_path('../..', __dir__)) unless defined?(ROOT_DIR)
+
+require "#{ROOT_DIR}/tasks/fact_generator/path"
+require "#{ROOT_DIR}/lib/framework/logging/multilogger"
+require "#{ROOT_DIR}/lib/framework/logging/legacy_logger"
+require "#{ROOT_DIR}/lib/framework/logging/logger"
+
+class FactCreator
+  def initialize
+    @log = Facter::Log.new(self)
+  end
+
+  def create_facts
+    facts_json_string = File.read(File.join(ROOT_DIR, 'tasks', 'fact_generator', 'facts.json'))
+    facts = JSON.parse(facts_json_string)
+
+    facts.each do |fact|
+      operating_system = fact['os']
+      fact_name = fact['fact_name']
+      create_fact(operating_system, fact_name)
+    end
+  end
+
+  def create_fact(operating_system, fact_name)
+    @log.info("Creating fact with name #{fact_name} for os #{operating_system}")
+
+    path = create_directory_path(operating_system, fact_name)
+    create_directory_structure(path)
+
+    create_fact_files(path, fact_name, operating_system)
+  end
+
+  private
+
+  def create_directory_path(operating_system, fact_name)
+    fact_tokens = fact_name.split('.')
+    fact_tokens = fact_tokens.first(fact_tokens.size - 1)
+
+    fact_directory = File.join(ROOT_DIR, 'lib', 'facts', operating_system, fact_tokens)
+    fact_spec_directory = File.join(ROOT_DIR, 'spec', 'facter', 'facts', operating_system, fact_tokens)
+    Path.new(fact_directory, fact_spec_directory)
+  end
+
+  def create_directory_structure(path)
+    FileUtils.mkdir_p(path.fact) unless File.directory?(path.fact)
+    FileUtils.mkdir_p(path.spec) unless File.directory?(path.spec)
+  end
+
+  def create_fact_files(path, fact_name, operating_system)
+    create_fact_file(path.fact, fact_name, operating_system)
+    create_spec_file(path.spec, fact_name, operating_system)
+  end
+
+  def create_fact_file(fact_path, fact_name, operating_system)
+    fact_tokens = fact_name.split('.')
+    fact_file_name = fact_tokens.reverse.first + '.rb'
+    fact_file_with_path = File.join(fact_path, fact_file_name)
+
+    return if File.exist?(fact_file_with_path)
+
+    fact_file = File.new(File.join(fact_path, fact_file_name), 'w')
+    fact_class_content = create_fact_from_template(fact_name, operating_system)
+    fact_file.write(fact_class_content)
+  end
+
+  def create_spec_file(spec_path, fact_name, operating_system)
+    fact_tokens = fact_name.split('.')
+    spec_file_name = fact_tokens.reverse.first + '_spec.rb'
+    spec_file_with_path = File.join(spec_path, spec_file_name)
+
+    return if File.exist?(spec_file_with_path)
+
+    spec_file = File.new(File.join(spec_path, spec_file_name), 'w')
+    spec_class_content = create_spec_from_template(fact_name, operating_system)
+    spec_file.write(spec_class_content)
+  end
+
+  def create_fact_from_template(fact_name, operating_system)
+    delimiters = ['.', '_']
+    fact_tokens = fact_name.split(Regexp.union(delimiters))
+    template = ERB.new(File.read(File.join(ROOT_DIR, 'tasks', 'fact_generator', 'fact.erb')))
+
+    os_name = operating_system.capitalize
+    camelcase_fact_name = fact_tokens.map(&:capitalize).join('')
+    template.result(binding)
+  end
+
+  def create_spec_from_template(fact_name, operating_system)
+    delimiters = ['.', '_']
+    fact_tokens = fact_name.split(Regexp.union(delimiters))
+    template = ERB.new(File.read(File.join(ROOT_DIR, 'tasks', 'fact_generator', 'fact_spec.erb')))
+
+    os_name = operating_system.capitalize
+    camelcase_fact_name = fact_tokens.map(&:capitalize).join('')
+    template.result(binding)
+  end
+end

data/tasks/fact_generator/fact_spec.erb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+describe '<%= os_name %> <%= camelcase_fact_name %>' do
+  context '#call_the_resolver' do
+    let(:value) { <fact_value> }
+    let(:expected_resolved_fact) { double(Facter::ResolvedFact, name: '<%= fact_name %>', value: value) }
+    subject(:fact) { Facter::<%= os_name %>::<%= camelcase_fact_name %>.new }
+
+    before do
+      expect(<resolver_name>).to receive(:resolve).with(<resolver_fact>).and_return(value)
+      expect(Facter::ResolvedFact).to receive(:new).with('<%= fact_name %>', value).and_return(expected_resolved_fact)
+    end
+
+    it 'returns <%= fact_name %> fact' do
+      expect(fact.call_the_resolver).to eq(expected_resolved_fact)
+    end
+  end
+end

data/tasks/fact_generator/facts.json

@@ -0,0 +1,358 @@
+[
+  {
+    "os":"macosx",
+    "fact_name":"aio_agent_version"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"augeas.version"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"dmi.product.name"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"facterversion"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"filesystems"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"identity.gid"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"identity.group"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"identity.privileged"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"identity.uid"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"identity.user"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"is_virtual"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"kernel"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"kernelmajversion"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"kernelrelease"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"kernelversion"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"load_averages"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.available"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.available_bytes"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.capacity"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.encrypted"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.total"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.total_bytes"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.used"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.swap.used_bytes"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.system.available"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.system.available_bytes"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.system.capacity"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.system.total"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.system.total_bytes"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.system.used"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"memory.system.used_bytes"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"mountpoints"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.dhcp"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.domain"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.fqdn"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.hostname"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.interfaces"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.ip"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.ip6"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.mac"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.mtu"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.netmask"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.netmask6"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.network"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.network6"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"networking.primary"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.architecture"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.family"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.hardware"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.macosx.build"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.macosx.product"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.macosx.version"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.name"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"os.release"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"path"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"processors.count"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"processors.isa"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"processors.models"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"processors.physicalcount"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"processors.speed"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"ruby.platform"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"ruby.sitedir"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"ruby.version"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.boot_mode"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.boot_rom_version"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.boot_volume"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.computer_name"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.cores"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.hardware_uuid"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.kernel_version"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.l2_cache_per_core"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.l3_cache"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.memory"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.model_identifier"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.model_name"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.processor_name"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.processor_speed"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.processors"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.secure_virtual_memory"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.serial_number"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.system_version"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.uptime"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_profiler.username"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_uptime.days"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_uptime.hours"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_uptime.seconds"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"system_uptime.uptime"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"timezone"
+  },
+  {
+    "os":"macosx",
+    "fact_name":"virtual"
+  }
+]