foreman_ansible 6.3.3 → 7.0.0

data/app/services/foreman_ansible/fact_parser.rb

@@ -1,126 +0,0 @@
-# frozen_string_literal: true
-
-module ForemanAnsible
-  # Override methods from Foreman app/services/fact_parser so that facts
-  # representing host properties are understood when they come from Ansible.
-  class FactParser < ::FactParser
-    include OperatingSystemParser
-    attr_reader :facts
-
-    def initialize(facts)
-      @facts = HashWithIndifferentAccess.new(facts[:ansible_facts])
-    end
-
-    # Don't do anything as there's no env in Ansible
-    def environment; end
-
-    def architecture
-      name = facts[:ansible_architecture] || facts[:facter_architecture]
-      Architecture.where(:name => name).first_or_create if name.present?
-    end
-
-    def model
-      name = detect_fact([:ansible_product_name, :facter_virtual,
-                          :facter_productname, :facter_model, :model])
-      Model.where(:name => name.strip).first_or_create if name.present?
-    end
-
-    def domain
-      name = detect_fact([:ansible_domain, :facter_domain,
-                          :ohai_domain, :domain])
-      Domain.where(:name => name).first_or_create if name.present?
-    end
-
-    def support_interfaces_parsing?
-      true
-    end
-
-    # Move ansible's default interface first in the list of interfaces since
-    # Foreman picks the first one that is usable. If ansible has no
-    # preference otherwise at least sort the list.
-    #
-    # This method overrides app/services/fact_parser.rb on Foreman and returns
-    # an array of interface names, ['eth0', 'wlan1', etc...]
-    def get_interfaces # rubocop:disable Naming/AccessorMethodName
-      pref = facts[:ansible_default_ipv4] &&
-             facts[:ansible_default_ipv4]['interface']
-      if pref.present?
-        (facts[:ansible_interfaces] - [pref]).unshift(pref)
-      else
-        ansible_interfaces
-      end
-    end
-
-    def get_facts_for_interface(iface_name)
-      interface = iface_name.tr('-', '_') # virbr1-nic -> virbr1_nic
-      interface_facts = facts[:"ansible_#{interface}"]
-      ipaddress = ip_from_interface(interface)
-      ipaddress6 = ipv6_from_interface(interface)
-      macaddress = mac_from_interface(interface)
-      iface_facts = HashWithIndifferentAccess[
-        interface_facts.merge(:ipaddress => ipaddress,
-                              :ipaddress6 => ipaddress6,
-                              :macaddress => macaddress)
-      ]
-      logger.debug { "Ansible interface #{interface} facts: #{iface_facts.inspect}" }
-      iface_facts
-    end
-
-    def ipmi_interface; end
-
-    def boot_timestamp
-      Time.zone.now.to_i - facts['ansible_uptime_seconds'].to_i
-    end
-
-    def virtual
-      facts['ansible_virtualization_role'] == 'guest'
-    end
-
-    def ram
-      facts['ansible_memtotal_mb'].to_i
-    end
-
-    def sockets
-      facts['ansible_processor_count'].to_i
-    end
-
-    def cores
-      facts['ansible_processor_cores'].to_i
-    end
-
-    private
-
-    def ansible_interfaces
-      return [] if facts[:ansible_interfaces].blank?
-      facts[:ansible_interfaces].sort
-    end
-
-    def mac_from_interface(interface)
-      facts[:"ansible_#{interface}"]['perm_macaddress'].presence || facts[:"ansible_#{interface}"]['macaddress']
-    end
-
-    def ip_from_interface(interface)
-      return if facts[:"ansible_#{interface}"]['ipv4'].blank?
-      if facts[:"ansible_#{interface}"]['ipv4'].is_a?(Array)
-        facts[:"ansible_#{interface}"]['ipv4'][0]['address']
-      else
-        facts[:"ansible_#{interface}"]['ipv4']['address']
-      end
-    end
-
-    def ipv6_from_interface(interface)
-      return if facts[:"ansible_#{interface}"]['ipv6'].blank?
-
-      facts[:"ansible_#{interface}"]['ipv6'].first['address']
-    end
-
-    # Returns first non-empty fact. Needed to check for empty strings.
-    def detect_fact(fact_names)
-      facts[
-        fact_names.detect do |fact_name|
-          facts[fact_name].present?
-        end
-      ]
-    end
-  end
-end

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/lib/foreman_ansible_core/ansible_runner_test.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module ForemanAnsibleCore
-  module Runner
-    class AnsibleRunnerTest < ActiveSupport::TestCase
-      describe AnsibleRunner do
-        it 'parses files without event data' do
-          content = <<~JSON
-            {"uuid": "a29d8592-f805-4d0e-b73d-7a53cc35a92e", "stdout": " [WARNING]: Consider using the yum module rather than running 'yum'.  If you", "counter": 8, "end_line": 8, "runner_ident": "e2d9ae11-026a-4f9f-9679-401e4b852ab0", "start_line": 7, "event": "verbose"}
-          JSON
-
-          File.expects(:read).with('fake.json').returns(content)
-          runner = AnsibleRunner.allocate
-          runner.expects(:handle_broadcast_data)
-          assert runner.send(:handle_event_file, 'fake.json')
-        end
-      end
-
-      describe '#rebuild_secrets' do
-        let(:inventory) do
-          { 'all' => { 'hosts' => ['foreman.example.com'] },
-            '_meta' => { 'hostvars' => { 'foreman.example.com' => {} } } }
-        end
-        let(:input) do
-          host_secrets = { 'ansible_password' => 'letmein', 'ansible_become_password' => 'iamroot' }
-          secrets = { 'per-host' => { 'foreman.example.com' => host_secrets } }
-          host_input = { 'input' => { 'action_input' => { 'secrets' => secrets } } }
-          { 'foreman.example.com' => host_input }
-        end
-        let(:runner) { ForemanAnsibleCore::Runner::AnsibleRunner.allocate }
-
-        test 'uses secrets from inventory' do
-          test_inventory = inventory.merge('ssh_password' => 'sshpass', 'effective_user_password' => 'mypass')
-          rebuilt = runner.send(:rebuild_secrets, test_inventory, input)
-          host_vars = rebuilt.dig('_meta', 'hostvars', 'foreman.example.com')
-          assert_equal 'sshpass', host_vars['ansible_password']
-          assert_equal 'mypass', host_vars['ansible_become_password']
-        end
-
-        test 'host secrets are used when not overriden by inventory secrest' do
-          rebuilt = runner.send(:rebuild_secrets, inventory, input)
-          host_vars = rebuilt.dig('_meta', 'hostvars', 'foreman.example.com')
-          assert_equal 'letmein', host_vars['ansible_password']
-          assert_equal 'iamroot', host_vars['ansible_become_password']
-        end
-      end
-    end
-  end
-end

data/test/unit/lib/foreman_ansible_core/command_creator_test.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class CommandCreatorTest < ActiveSupport::TestCase
-  let(:inventory_file) { 'test_inventory' }
-  let(:playbook_file) { 'test_palybook.yml' }
-  subject do
-    ForemanAnsibleCore::CommandCreator.new(inventory_file, playbook_file, {})
-  end
-
-  test 'returns a command array including the ansible-playbook command' do
-    assert command_parts.include?('ansible-playbook')
-  end
-
-  test 'the last argument is the playbook_file' do
-    assert command_parts.last == playbook_file
-  end
-
-  describe 'environment variables' do
-    let(:environment_variables) { subject.command.first }
-
-    test 'has a JSON_INVENTORY_FILE set' do
-      assert environment_variables['JSON_INVENTORY_FILE']
-    end
-
-    test 'has no ANSIBLE_CALLBACK_WHITELIST set by default' do
-      assert_not environment_variables['ANSIBLE_CALLBACK_WHITELIST']
-    end
-
-    test 'with a REX command it sets ANSIBLE_CALLBACK_WHITELIST to empty' do
-      set_command_options(:remote_execution_command, true)
-      assert environment_variables['ANSIBLE_CALLBACK_WHITELIST']
-    end
-  end
-
-  describe 'command options' do
-    it 'can have verbosity set' do
-      level = '3'
-      level_string = Array.new(level.to_i).map { 'v' }.join
-      set_command_options(:verbosity_level, level)
-      assert command_parts.any? do |part|
-        part == "-#{level_string}"
-      end
-    end
-
-    it 'can have a timeout set' do
-      timeout = '5555'
-      set_command_options(:timeout, timeout)
-      assert command_parts.include?(timeout)
-    end
-  end
-
-  private
-
-  def command_parts
-    subject.command.flatten.map(&:to_s)
-  end
-
-  def set_command_options(option, value)
-    subject.instance_eval("@options[:#{option}] = \"#{value}\"",
-                          __FILE__, __LINE__ - 1)
-  end
-end

data/test/unit/lib/foreman_ansible_core/playbook_runner_test.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-# Playbook Runner - this class uses foreman_tasks_core
-# to run playbooks
-class PlaybookRunnerTest < ActiveSupport::TestCase
-  context 'roles dir' do
-    test 'reads default when none provided' do
-      ForemanAnsibleCore::Runner::Playbook.any_instance.stubs(:unknown_hosts).
-        returns([])
-      File.expects(:exist?).with(Dir.home).returns(true)
-      ForemanAnsibleCore::Runner::Playbook.any_instance.expects(:rebuild_secrets).returns(nil)
-      runner = ForemanAnsibleCore::Runner::Playbook.new(nil, nil, :suspended_action => nil)
-      assert '/etc/ansible', runner.instance_variable_get('@ansible_dir')
-    end
-  end
-
-  context 'working_dir' do
-    setup do
-      ForemanAnsibleCore::Runner::Playbook.any_instance.stubs(:unknown_hosts).
-        returns([])
-    end
-
-    test 'creates temp one if not provided' do
-      Dir.expects(:mktmpdir)
-      File.expects(:exist?).with(Dir.home).returns(true)
-      ForemanAnsibleCore::Runner::Playbook.any_instance.expects(:rebuild_secrets).returns(nil)
-      ForemanAnsibleCore::Runner::Playbook.new(nil, nil, :suspended_action => nil)
-    end
-
-    test 'reads it when provided' do
-      settings = { :working_dir => '/foo', :ansible_dir => '/etc/foo' }
-      ForemanAnsibleCore.expects(:settings).returns(settings)
-      File.expects(:exist?).with(settings[:ansible_dir]).returns(true)
-      Dir.expects(:mktmpdir).never
-      ForemanAnsibleCore::Runner::Playbook.any_instance.expects(:rebuild_secrets).returns(nil)
-      runner = ForemanAnsibleCore::Runner::Playbook.new(nil, nil, :suspended_action => nil)
-      assert '/foo', runner.instance_variable_get('@working_dir')
-    end
-  end
-
-  context 'TOFU policy' do # Trust On First Use
-    setup do
-      @inventory = { 'all' => { 'hosts' => ['foreman.example.com'] } }
-      @output = StringIO.new
-      logger = Logger.new(@output)
-      ForemanAnsibleCore::Runner::Playbook.any_instance.stubs(:logger).
-        returns(logger)
-    end
-
-    test 'ignores known hosts' do
-      Net::SSH::KnownHosts.expects(:search_for).
-        with('foreman.example.com').returns(['somekey'])
-      ForemanAnsibleCore::Runner::Playbook.any_instance.
-        expects(:add_to_known_hosts).never
-      ForemanAnsibleCore::Runner::Playbook.any_instance.expects(:rebuild_secrets).returns(@inventory)
-      ForemanAnsibleCore::Runner::Playbook.new(@inventory, nil, :suspended_action => nil)
-    end
-
-    test 'adds unknown hosts to known_hosts' do
-      Net::SSH::KnownHosts.expects(:search_for).
-        with('foreman.example.com').returns([])
-      ForemanAnsibleCore::Runner::Playbook.any_instance.
-        expects(:add_to_known_hosts).with('foreman.example.com')
-      ForemanAnsibleCore::Runner::Playbook.any_instance.expects(:rebuild_secrets).returns(@inventory)
-      ForemanAnsibleCore::Runner::Playbook.new(@inventory, nil, :suspended_action => nil)
-    end
-
-    test 'logs error when it cannot add to known_hosts' do
-      Net::SSH::KnownHosts.expects(:search_for).
-        with('foreman.example.com').returns([])
-      Net::SSH::Transport::Session.expects(:new).with('foreman.example.com').
-        raises(Net::Error)
-      ForemanAnsibleCore::Runner::Playbook.any_instance.expects(:rebuild_secrets).returns(@inventory)
-      ForemanAnsibleCore::Runner::Playbook.new(@inventory, nil, :suspended_action => nil)
-      assert_match(
-        /ERROR.*Failed to save host key for foreman.example.com: Net::Error/,
-        @output.string
-      )
-    end
-  end
-
-  context 'rebuild secrets' do
-    let(:inventory) do
-      { 'all' => { 'hosts' => ['foreman.example.com'] },
-        '_meta' => { 'hostvars' => { 'foreman.example.com' => {} } } }
-    end
-    let(:secrets) do
-      host_secrets = { 'ansible_password' => 'letmein', 'ansible_become_password' => 'iamroot' }
-      { 'per-host' => { 'foreman.example.com' => host_secrets } }
-    end
-    let(:runner) { ForemanAnsibleCore::Runner::Playbook.allocate }
-
-    test 'uses secrets from inventory' do
-      test_inventory = inventory.merge('ssh_password' => 'sshpass', 'effective_user_password' => 'mypass')
-      rebuilt = runner.send(:rebuild_secrets, test_inventory, secrets)
-      host_vars = rebuilt.dig('_meta', 'hostvars', 'foreman.example.com')
-      assert_equal 'sshpass', host_vars['ansible_password']
-      assert_equal 'mypass', host_vars['ansible_become_password']
-    end
-
-    test 'host secrets are used when not overriden by inventory secrest' do
-      rebuilt = runner.send(:rebuild_secrets, inventory, secrets)
-      host_vars = rebuilt.dig('_meta', 'hostvars', 'foreman.example.com')
-      assert_equal 'letmein', host_vars['ansible_password']
-      assert_equal 'iamroot', host_vars['ansible_become_password']
-    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