foreman_ansible 6.4.1 → 7.0.0

data/app/services/foreman_ansible/fact_sparser.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module ForemanAnsible
-  # See sparse and unsparse documentation
-  class FactSparser
-    class << self
-      # Sparses facts, so that it converts a facts hash
-      # { operatingsystem : { major: 20, name : 'fedora' }
-      # into
-      # { operatingsystem::major: 20,
-      #   operatingsystem::name: 'fedora' }
-      def sparse(hash, options = {})
-        hash.map do |k, v|
-          prefix = options.fetch(:prefix, []) + [k]
-          next sparse(v, options.merge(:prefix => prefix)) if v.is_a? Hash
-          { prefix.join(options.fetch(:separator, FactName::SEPARATOR)) => v }
-        end.reduce(:merge) || {}
-      end
-
-      # Unsparses facts, so that it converts a hash with facts
-      # { operatingsystem::major: 20,
-      #   operatingsystem::name: 'fedora' }
-      # into
-      # { operatingsystem : { major: 20, name: 'fedora' } }
-      def unsparse(facts_hash)
-        ret = {}
-        sparse(facts_hash).each do |full_name, value|
-          current = ret
-          fact_name = full_name.to_s.split(FactName::SEPARATOR)
-          current = (current[fact_name.shift] ||= {}) until fact_name.size <= 1
-          current[fact_name.first] = value
-        end
-        ret
-      end
-    end
-  end
-end

data/app/services/foreman_ansible/operating_system_parser.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module ForemanAnsible
-  # Methods to parse facts related to the OS
-  module OperatingSystemParser
-    def operatingsystem
-      args = { :name => os_name, :major => os_major, :minor => os_minor }
-      args[:release_name] = os_release_name if os_name == 'Debian' || os_name == 'Ubuntu'
-      return @local_os if local_os(args).present?
-      return @new_os if new_os(args).present?
-      logger.debug do
-        'Ansible facts parser: No OS could be created with '\
-        "os_name='#{os_name}' os_major='#{os_major}' "\
-        "os_minor='#{os_minor}': "\
-        "#{@new_os.errors if @new_os.present?}"
-      end
-      nil
-    end
-
-    def local_os(args)
-      @local_os = Operatingsystem.where(args).first
-    end
-
-    def new_os(args)
-      return @new_os if @new_os.present?
-      @new_os = Operatingsystem.new(args.merge(:description => os_description))
-      @new_os if @new_os.valid? && @new_os.save
-    end
-
-    def debian_os_major_sid
-      case facts[:ansible_distribution_major_version]
-      when /wheezy/i
-        '7'
-      when /jessie/i
-        '8'
-      when /stretch/i
-        '9'
-      when /buster/i
-        '10'
-      end
-    end
-
-    def os_release_name
-      return '' if os_name != 'Debian' && os_name != 'Ubuntu'
-      facts[:ansible_distribution_release]
-    end
-
-    def os_major
-      if os_name == 'Debian' &&
-         facts[:ansible_distribution_major_version][%r{\/sid}i]
-        debian_os_major_sid
-      else
-        facts[:ansible_distribution_major_version] ||
-          facts[:ansible_lsb] && facts[:ansible_lsb]['major_release'] ||
-          (facts[:version].split('R')[0] if os_name == 'junos')
-      end
-    end
-
-    def os_release
-      facts[:ansible_distribution_version] ||
-        facts[:ansible_lsb] && facts[:ansible_lsb]['release']
-    end
-
-    def os_minor
-      _, minor = os_release&.split('.', 2) ||
-                 (facts[:version].split('R') if os_name == 'junos')
-      # Until Foreman supports os.minor as something that's not a number,
-      # we should remove the extra dots in the version. E.g:
-      # '6.1.7601.65536' becomes '6.1.760165536'
-      if facts[:ansible_os_family] == 'Windows'
-        minor, patch = minor.split('.', 2)
-        patch.tr!('.', '')
-        minor = "#{minor}.#{patch}"
-      end
-      minor || ''
-    end
-
-    def os_name
-      if facts[:ansible_os_family] == 'Windows'
-        facts[:ansible_os_name].tr(" \n\t", '') ||
-          facts[:ansible_distribution].tr(" \n\t", '')
-      else
-        distribution = facts[:ansible_lsb].try(:[], 'id') || facts[:ansible_distribution]
-
-        if distribution == 'RedHat' &&
-           facts[:ansible_lsb].try(:[], 'id') == 'RedHatEnterpriseWorkstation'
-          distribution += '_Workstation'
-        end
-
-        distribution
-      end
-    end
-
-    def os_description
-      if facts[:ansible_os_family] == 'Windows'
-        facts[:ansible_os_name].strip || facts[:ansible_distribution].strip
-      else
-        facts[:ansible_lsb] && facts[:ansible_lsb]['description']
-      end
-    end
-  end
-end

data/app/services/foreman_ansible/structured_fact_importer.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module ForemanAnsible
-  # On 1.13+ , use the parser for structured facts (like Facter 2) that comes
-  # from core
-  class StructuredFactImporter < ::StructuredFactImporter
-    def fact_name_class
-      ForemanAnsible::FactName
-    end
-
-    def self.authorized_smart_proxy_features
-      'Ansible'
-    end
-
-    def initialize(host, facts = {})
-      # Try to assign these facts to the correct host as per the facts say
-      # If that host isn't created yet, the host parameter will contain it
-      @host = Host.find_by(:name => facts[:ansible_facts][:ansible_fqdn] ||
-                                    facts[:ansible_facts][:fqdn]) ||
-              host
-      @facts = normalize(facts[:ansible_facts])
-      @counters = {}
-    end
-  end
-end

data/test/unit/services/fact_importer_test.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_plugin_helper'
-
-module ForemanAnsible
-  # Test for the facts importer - only verify that given
-  # a set of facts it's able to import them
-  class FactImporterTest < ActiveSupport::TestCase
-    setup do
-      @host = FactoryBot.build(:host)
-    end
-
-    test 'add new facts adds all fact names in the fixture' do
-      @fact_importer = FactImporter.new(@host, facts_json)
-      facts_to_be_added = FactSparser.sparse(facts_json[:ansible_facts]).keys +
-                          FactSparser.unsparse(facts_json[:ansible_facts]).keys
-      @fact_importer.send(:add_new_facts)
-      assert((facts_to_be_added - FactName.all.map(&:name)).empty?)
-    end
-
-    test 'missing_facts returns facts we do not have in the database' do
-      @fact_importer = FactImporter.new(@host, facts_json)
-      @fact_importer.expects(:host_fact_names).
-        returns(['ansible_cmdline'])
-      refute @fact_importer.send(:missing_facts).include?('ansible_cmdline')
-    end
-
-    describe '#add_fact_value' do
-      setup do
-        @fact_importer = FactImporter.new(@host, :ansible_facts => {})
-      end
-      test 'does not add existing facts' do
-        existing_fact = FactoryBot.build(:fact_name)
-        @fact_importer.expects(:missing_facts).returns([])
-        assert_nil @fact_importer.send(:add_fact_value, nil, existing_fact)
-      end
-
-      test 'adds missing facts' do
-        missing_fact = FactoryBot.build(:fact_name)
-        @fact_importer.expects(:missing_facts).returns([missing_fact.name])
-        @fact_importer.counters[:added] = 0
-        assert_difference('@host.fact_values.count', 1) do
-          @fact_importer.send(:add_fact_value, 'missing_value', missing_fact)
-          @host.save
-          # We have to save the host in order to ensure @host.fact_values.count
-          # resolves properly (otherwise) :add_fact_value just won't save the
-          # relation
-        end
-      end
-    end
-  end
-end

data/test/unit/services/fact_parser_test.rb

@@ -1,281 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_plugin_helper'
-
-module ForemanAnsible
-  # Checks sample Ansible facts to see if it can assign them to
-  # Host properties
-  class FactParserTest < ActiveSupport::TestCase
-    setup do
-      @facts_parser = ForemanAnsible::FactParser.new(facts_json)
-    end
-
-    test 'finds facter domain even if ansible_domain is empty' do
-      expect_where(Domain, @facts_parser.facts[:facter_domain])
-      @facts_parser.domain
-    end
-
-    test 'finds model' do
-      expect_where(Model, @facts_parser.facts[:ansible_product_name])
-      @facts_parser.model
-    end
-
-    test 'finds architecture' do
-      expect_where(Architecture, @facts_parser.facts[:ansible_architecture])
-      @facts_parser.architecture
-    end
-
-    test 'does not set environment' do
-      refute @facts_parser.environment
-    end
-
-    test 'calculates virtual reported data' do
-      refute @facts_parser.virtual
-    end
-
-    test 'calculates ram reported data' do
-      assert_equal 7899, @facts_parser.ram
-    end
-
-    test 'calculates sockets reported data' do
-      assert_equal 1, @facts_parser.sockets
-    end
-
-    test 'calculates cores reported data' do
-      assert_equal 2, @facts_parser.cores
-    end
-
-    test 'creates operatingsystem from operating system options' do
-      sample_mock = mock
-      major_fact = @facts_parser.facts['ansible_distribution_major_version']
-      _, minor_fact = @facts_parser.
-                      facts['ansible_distribution_version'].split('.')
-      Operatingsystem.expects(:where).
-        with(:name => @facts_parser.facts['ansible_distribution'],
-             :major => major_fact, :minor => minor_fact || '').
-        returns(sample_mock)
-      sample_mock.expects(:first)
-      @facts_parser.operatingsystem
-    end
-
-    test 'does not fail if facts are not enough to create OS' do
-      @facts_parser.expects(:os_name).returns('fakeos').at_least_once
-      @facts_parser.expects(:os_major).returns('').at_least_once
-      @facts_parser.expects(:os_minor).returns('').at_least_once
-      @facts_parser.expects(:os_description).returns('').at_least_once
-      Operatingsystem.any_instance.expects(:valid?).returns(false)
-      assert_nil @facts_parser.operatingsystem
-    end
-
-    private
-
-    def expect_where(model, fact_name)
-      sample_mock = mock
-      model.expects(:where).
-        with(:name => fact_name).
-        returns(sample_mock)
-      sample_mock.expects(:first_or_create)
-    end
-  end
-
-  # Tests for Network parser
-  class NetworkFactParserTest < ActiveSupport::TestCase
-    setup do
-      @facts_parser = ForemanAnsible::FactParser.new(
-        HashWithIndifferentAccess.new(
-          '_type' => 'ansible',
-          '_timestamp' => '2018-10-29 20:01:51 +0100',
-          'ansible_facts' =>
-          {
-            'ansible_interfaces' => %w[eth0 eth1 eth2 bond0],
-            'ansible_eth0' => {
-              'active' => true,
-              'device' => 'eth0',
-              'macaddress' => '52:54:00:04:55:37',
-              'perm_macaddress' => '52:54:00:04:55:37',
-              'ipv4' => {
-                  'address' => '10.10.0.10',
-                  'netmask' => '255.255.0.0',
-                  'network' => '10.10.0.0'
-              },
-              'ipv6' => [
-                  {
-                      'address' => 'fd00::5054:00ff:fe04:5537',
-                      'prefix' => '64',
-                      'scope' => 'host'
-                  }
-              ],
-              'mtu' => 1500,
-              'promisc' => false,
-              'type' => 'ether'
-            },
-            'ansible_eth1' => {
-              'active' => true,
-              'device' => 'eth1',
-              'macaddress' => '52:54:00:04:55:38',
-              'perm_macaddress' => '52:54:00:04:55:38',
-              'mtu' => 1500,
-              'promisc' => false,
-              'type' => 'ether'
-            },
-            'ansible_eth2' => {
-              'active' => true,
-              'device' => 'eth2',
-              'macaddress' => '52:54:00:04:55:38',
-              'perm_macaddress' => '52:54:00:04:55:39',
-              'mtu' => 1500,
-              'promisc' => false,
-              'type' => 'ether'
-            },
-            'ansible_bond0' => {
-              'active' => true,
-              'device' => 'bond0',
-              'macaddress' => '52:54:00:04:55:38',
-              'ipv4' => {
-                  'address' => '10.10.0.11',
-                  'netmask' => '255.255.0.0',
-                  'network' => '10.10.0.0'
-              },
-              'ipv6' => [
-                  {
-                      'address' => 'fd00::5054:00ff:fe04:5538',
-                      'prefix' => '64',
-                      'scope' => 'host'
-                  }
-              ],
-              'mtu' => 1500,
-              'promisc' => false,
-              'slaves' => %w[eth1 eth2],
-              'type' => 'bonding'
-            }
-          }
-        )
-      )
-    end
-
-    test 'Parses IPv4 & IPv6 addresses correctly' do
-      iut = 'eth0'.dup
-      interface = @facts_parser.get_facts_for_interface(iut)
-      assert_equal '10.10.0.10', interface['ipaddress']
-      assert_equal 'fd00::5054:00ff:fe04:5537', interface['ipaddress6']
-    end
-
-    test 'Parses MAC address correctly when bonded' do
-      iut0 = 'eth0'.dup
-      iut1 = 'eth1'.dup
-      iut2 = 'eth2'.dup
-      but0 = 'bond0'.dup
-      interface_eth0 = @facts_parser.get_facts_for_interface(iut0)
-      interface_eth1 = @facts_parser.get_facts_for_interface(iut1)
-      interface_eth2 = @facts_parser.get_facts_for_interface(iut2)
-      interface_bond0 = @facts_parser.get_facts_for_interface(but0)
-      assert_equal '52:54:00:04:55:37', interface_eth0['macaddress']
-      assert_equal '52:54:00:04:55:38', interface_eth1['macaddress']
-      assert_equal '52:54:00:04:55:39', interface_eth2['macaddress']
-      assert_equal '52:54:00:04:55:38', interface_bond0['macaddress']
-    end
-  end
-
-  # Tests for Debian parser
-  class DebianFactParserTest < ActiveSupport::TestCase
-    setup do
-      @facts_parser = ForemanAnsible::FactParser.new(
-        HashWithIndifferentAccess.new(
-          '_type' => 'ansible',
-          '_timestamp' => '2015-10-29 20:01:51 +0100',
-          'ansible_facts' =>
-          {
-            "ansible_distribution" => "Debian",
-            "ansible_distribution_file_parsed" => true,
-            "ansible_distribution_file_path" => "/etc/os-release",
-            "ansible_distribution_file_variety" => "Debian",
-            "ansible_distribution_major_version" => "8",
-            "ansible_distribution_release" => "jessie",
-            "ansible_distribution_version" => "8.7"
-          }
-        )
-      )
-    end
-
-    test 'Parses debian jessie correctly' do
-      as_admin do
-        os = @facts_parser.operatingsystem
-
-        assert_equal '8', os.major
-        assert_equal 'Debian', os.name
-      end
-    end
-  end
-
-  # Tests for Windows parser
-  class WindowsFactParserTest < ActiveSupport::TestCase
-    context 'Windows 7' do
-      setup do
-        @facts_parser = ForemanAnsible::FactParser.new(
-          HashWithIndifferentAccess.new(
-            '_type' => 'ansible',
-            '_timestamp' => '2015-10-29 20:01:51 +0100',
-            'ansible_facts' => {
-              'ansible_architecture' => '32-Bit',
-              'ansible_distribution' => 'Microsoft Windows 7 Enterprise ',
-              'ansible_distribution_major_version' => '6',
-              'ansible_distribution_version' => '6.1.7601.65536',
-              'ansible_os_family' => 'Windows',
-              'ansible_os_name' => 'Microsoft Windows 7 Enterprise',
-              'ansible_product_name' => 'DS61',
-              'ansible_product_serial' => 'To be filled by O.E.M.',
-              'ansible_system' => 'Win32NT',
-              'ansible_win_rm_certificate_expires' => '2021-01-23 15:08:48',
-              'ansible_windows_domain' => 'example.com'
-            }
-          )
-        )
-      end
-
-      test 'parses Windows 7 Enterprise correctly' do
-        os = @facts_parser.operatingsystem
-        assert_equal '6', os.major
-        assert_equal '6.1.760165536', os.release
-        assert_equal '1.760165536', os.minor
-        assert_equal 'Windows', os.family
-        assert_equal 'Microsoft Windows 7 Enterprise', os.description
-        assert_equal 'MicrosoftWindows7Enterprise', os.name
-        assert os.valid?
-      end
-    end
-
-    context 'Windows Server 2016' do
-      setup do
-        @facts_parser = ForemanAnsible::FactParser.new(
-          HashWithIndifferentAccess.new(
-            '_type' => 'ansible',
-            '_timestamp' => '2015-10-29 20:01:51 +0100',
-            'ansible_facts' => {
-              'ansible_architecture' => '64-Bit',
-              'ansible_distribution' => 'Microsoft Windows Server 2016 '\
-                                        'Standard',
-              'ansible_distribution_major_version' => '10',
-              'ansible_distribution_version' => '10.0.14393.0',
-              'ansible_os_family' => 'Windows',
-              'ansible_os_name' => 'Microsoft Windows Server 2016 Standard',
-              'ansible_system' => 'Win32NT',
-              'ansible_win_rm_certificate_expires' => '2021-01-23 15:08:48',
-              'ansible_windows_domain' => 'example.com'
-            }
-          )
-        )
-      end
-
-      test 'parses Windows Server correctly' do
-        os = @facts_parser.operatingsystem
-        assert_equal '10', os.major
-        assert_equal '10.0.143930', os.release
-        assert_equal '0.143930', os.minor
-        assert_equal 'Windows', os.family
-        assert_equal 'Microsoft Windows Server 2016 Standard', os.description
-        assert_equal 'MicrosoftWindowsServer2016Standard', os.name
-        assert os.valid?
-      end
-    end
-  end
-end

data/test/unit/services/fact_sparser_test.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module ForemanAnsible
-  # Tests for checking if FactSparser can sparse a hash and unsparse it
-  class FactSparserTest < ActiveSupport::TestCase
-    setup do
-      @original_os_facts = { 'operatingsystem' => { 'major' => 20, 'minor' => 1,
-                                                    'name' => 'Fedora' } }
-      @sparsed_os_facts = { 'operatingsystem::major' => 20,
-                            'operatingsystem::minor' => 1,
-                            'operatingsystem::name' => 'Fedora' }
-    end
-
-    test 'sparses simple hash' do
-      assert_equal @sparsed_os_facts,
-                   ForemanAnsible::FactSparser.sparse(@original_os_facts)
-    end
-
-    test 'unsparse simple hash' do
-      assert_equal @original_os_facts,
-                   ForemanAnsible::FactSparser.unsparse(@sparsed_os_facts)
-    end
-  end
-end

data/test/unit/services/structured_fact_importer_test.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_plugin_helper'
-
-module ForemanAnsible
-  # Test for the structured facts importer - its code mostly lives in Foreman
-  # core, so only details have to be tested here.
-  class StructuredFactImporterTest < ActiveSupport::TestCase
-    test 'if host is not in Foreman, use hostname provided by call' do
-      fake_host = Host.new(:name => 'fake')
-      importer = ForemanAnsible::StructuredFactImporter.new(
-        fake_host,
-        facts_json
-      )
-      assert_equal fake_host, importer.send(:host)
-    end
-
-    test 'if host is in Foreman, use hostname provided by Ansible' do
-      ansible_fqdn_host = FactoryBot.build(:host)
-      ansible_fqdn_host.name = facts_json[:ansible_facts][:ansible_fqdn]
-      ansible_fqdn_host.save
-      importer = ForemanAnsible::StructuredFactImporter.new(
-        Host.new(:name => 'fake'),
-        facts_json
-      )
-
-      assert_equal ansible_fqdn_host, importer.send(:host)
-    end
-  end
-end