smart_proxy_ansible 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c78dd643ea513a8ffc694a01c86f12495aff1e1b14c7e106db9d29ab529d26d
-  data.tar.gz: 8b2fde1a83bf65fb55fc122ce8ff931fd314f5289f9cf34e255d85959bebb653
+  metadata.gz: 9ae7dee62b09f9ea49553d1e2efab2b3f535940be697cf132af28fe0096da30f
+  data.tar.gz: 1997fbe1d05cedb27ee1a8c05d38b2644a25b84e0fbd11a93f201c8f81647643
 SHA512:
-  metadata.gz: 695b0b451cc16439fd4fb76f9567f49e971c609c6d4696c19afa5feb3b90ac6a069e392ce38b177111041cae577662683cb6f594e86adc1096a6bfb5d7ac7ccc
-  data.tar.gz: 94a5bac7bce83785b0cc9067e9ffd20e9084e8befd575c3f6fae7da5ac7e78b202bf137daa36e6e726a8fd54de190180e42ac1af96ff6b2fcb1b9381364f2a59
+  metadata.gz: 30b1c1acfd7ca623ab1bc8ccbbd83cfa0b31c9c99516ea8414e500470fa67b9755a579f3f87d77abaca565f9b31ff1503b335224f7664c40bda8d3e7e4707ddd
+  data.tar.gz: 9135ef0523d5246271da5b559384d7a53b952a9da67301c00b975d3544e365fd73af156b1cdd77989af75ea98990b1d78c33cd8f7ad040dfd0fa62cfb6103645

data/lib/smart_proxy_ansible/actions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'smart_proxy_dynflow/action/runner'
+
+module Proxy::Ansible
+  module Actions
+    # Action that can be run both on Foreman or Foreman proxy side
+    # to execute the playbook run
+    class RunPlaybook < Proxy::Dynflow::Action::Runner
+      def initiate_runner
+        Proxy::Ansible::Runner::Playbook.new(
+          input[:inventory],
+          input[:playbook],
+          input[:options]
+        )
+      end
+    end
+  end
+end

data/lib/smart_proxy_ansible/api.rb

@@ -35,8 +35,8 @@ module Proxy
         role_name_parts = role_name.split('.')
         if role_name_parts.count == 3
           RolesReader.collections_paths.split(':').each do |path|
-            variables[role_name] = VariablesExtractor
-                                   .extract_variables("#{path}/ansible_collections/#{role_name_parts[0]}/#{role_name_parts[1]}/roles/#{role_name_parts[2]}") if variables[role_name].nil? || variables[role_name].empty?
+            variables[role_name] ||= VariablesExtractor
+                                   .extract_variables("#{path}/ansible_collections/#{role_name_parts[0]}/#{role_name_parts[1]}/roles/#{role_name_parts[2]}")
           end
         else
           RolesReader.roles_path.split(':').each do |path|

data/lib/smart_proxy_ansible/plugin.rb

@@ -5,16 +5,24 @@ module Proxy
       rackup_path File.expand_path('http_config.ru', __dir__)
       settings_file 'ansible.yml'
       plugin :ansible, Proxy::Ansible::VERSION
+      default_settings :ansible_dir => Dir.home
+                       # :working_dir => nil
 
       after_activation do
-        begin
-          require 'smart_proxy_dynflow_core'
-          require 'foreman_ansible_core'
-          ForemanAnsibleCore.initialize_settings(Proxy::Ansible::Plugin.settings.to_h)
-        rescue LoadError => _
-          # Dynflow core is not available in the proxy, will be handled
-          # by standalone Dynflow core
-        end
+        require 'smart_proxy_dynflow'
+        require 'smart_proxy_dynflow/continuous_output'
+        require 'smart_proxy_ansible/task_launcher/ansible_runner'
+        require 'smart_proxy_ansible/task_launcher/playbook'
+        require 'smart_proxy_ansible/actions'
+        require 'smart_proxy_ansible/remote_execution_core/ansible_runner'
+        require 'smart_proxy_ansible/runner/ansible_runner'
+        require 'smart_proxy_ansible/runner/command_creator'
+        require 'smart_proxy_ansible/runner/playbook'
+
+        Proxy::Dynflow::TaskLauncherRegistry.register('ansible-runner',
+          TaskLauncher::AnsibleRunner)
+        Proxy::Dynflow::TaskLauncherRegistry.register('ansible-playbook',
+          TaskLauncher::Playbook)
       end
     end
   end

data/lib/smart_proxy_ansible/remote_execution_core/ansible_runner.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'smart_proxy_dynflow/runner/command_runner'
+
+module Proxy::Ansible
+  module RemoteExecutionCore
+    # Takes an inventory and runs it through REXCore CommandRunner
+    class AnsibleRunner < ::Proxy::Dynflow::Runner::CommandRunner
+      DEFAULT_REFRESH_INTERVAL = 1
+      CONNECTION_PROMPT = 'Are you sure you want to continue connecting (yes/no)? '
+
+      def initialize(options, suspended_action:)
+        super(options, :suspended_action => suspended_action)
+        @playbook_runner = Proxy::Ansible::Runner::Playbook.new(
+          options['ansible_inventory'],
+          options['script'],
+          options,
+          :suspended_action => suspended_action
+        )
+      end
+
+      def start
+        @playbook_runner.logger = logger
+        @playbook_runner.start
+      rescue StandardError => e
+        logger.error(
+          'error while initalizing command'\
+          " #{e.class} #{e.message}:\n #{e.backtrace.join("\n")}"
+        )
+        publish_exception('Error initializing command', e)
+      end
+
+      def fill_continuous_output(continuous_output)
+        delegated_output.fetch('result', []).each do |raw_output|
+          continuous_output.add_raw_output(raw_output)
+        end
+      rescue StandardError => e
+        continuous_output.add_exception(_('Error loading data from proxy'), e)
+      end
+
+      def refresh
+        @command_out = @playbook_runner.command_out
+        @command_in = @playbook_runner.command_in
+        @command_pid = @playbook_runner.command_pid
+        super
+        kill if unknown_host_key_fingerprint?
+      end
+
+      def kill
+        publish_exit_status(1)
+        ::Process.kill('SIGTERM', @command_pid)
+        close
+      end
+
+      private
+
+      def unknown_host_key_fingerprint?
+        last_output = @continuous_output.raw_outputs.last
+        return if last_output.nil?
+        last_output['output']&.lines&.last == CONNECTION_PROMPT
+      end
+    end
+  end
+end

data/lib/smart_proxy_ansible/runner/ansible_runner.rb

@@ -0,0 +1,210 @@
+require 'shellwords'
+
+require 'smart_proxy_dynflow/runner/command'
+require 'smart_proxy_dynflow/runner/base'
+require 'smart_proxy_dynflow/runner/parent'
+module Proxy::Ansible
+  module Runner
+    class AnsibleRunner < ::Proxy::Dynflow::Runner::Parent
+      include ::Proxy::Dynflow::Runner::Command
+
+      def initialize(input, suspended_action:)
+        super input, :suspended_action => suspended_action
+        @inventory = rebuild_secrets(rebuild_inventory(input), input)
+        action_input = input.values.first[:input][:action_input]
+        @playbook = action_input[:script]
+        @root = working_dir
+        @verbosity_level = action_input[:verbosity_level]
+        @rex_command = action_input[:remote_execution_command]
+        @check_mode = action_input[:check_mode]
+        @tags = action_input[:tags]
+        @tags_flag = action_input[:tags_flag]
+      end
+
+      def start
+        prepare_directory_structure
+        write_inventory
+        write_playbook
+        start_ansible_runner
+      end
+
+      def refresh
+        return unless super
+        @counter ||= 1
+        @uuid ||= File.basename(Dir["#{@root}/artifacts/*"].first)
+        job_event_dir = File.join(@root, 'artifacts', @uuid, 'job_events')
+        loop do
+          files = Dir["#{job_event_dir}/*.json"].map do |file|
+            num = File.basename(file)[/\A\d+/].to_i unless file.include?('partial')
+            [file, num]
+          end
+          files_with_nums = files.select { |(_, num)| num && num >= @counter }.sort_by(&:last)
+          break if files_with_nums.empty?
+          logger.debug("[foreman_ansible] - processing event files: #{files_with_nums.map(&:first).inspect}}")
+          files_with_nums.map(&:first).each { |event_file| handle_event_file(event_file) }
+          @counter = files_with_nums.last.last + 1
+        end
+      end
+
+      def close
+        super
+        FileUtils.remove_entry(@root) if @tmp_working_dir
+      end
+
+      private
+
+      def handle_event_file(event_file)
+        logger.debug("[foreman_ansible] - parsing event file #{event_file}")
+        begin
+          event = JSON.parse(File.read(event_file))
+          if (hostname = event.dig('event_data', 'host'))
+            handle_host_event(hostname, event)
+          else
+            handle_broadcast_data(event)
+          end
+          true
+        rescue JSON::ParserError => e
+          logger.error("[foreman_ansible] - Error parsing runner event at #{event_file}: #{e.class}: #{e.message}")
+          logger.debug(e.backtrace.join("\n"))
+        end
+      end
+
+      def handle_host_event(hostname, event)
+        log_event("for host: #{hostname.inspect}", event)
+        publish_data_for(hostname, event['stdout'] + "\n", 'stdout') if event['stdout']
+        case event['event']
+        when 'runner_on_ok'
+          publish_exit_status_for(hostname, 0) if @exit_statuses[hostname].nil?
+        when 'runner_on_unreachable'
+          publish_exit_status_for(hostname, 1)
+        when 'runner_on_failed'
+          publish_exit_status_for(hostname, 2) if event.dig('event_data', 'ignore_errors').nil?
+        end
+      end
+
+      def handle_broadcast_data(event)
+        log_event("broadcast", event)
+        if event['event'] == 'playbook_on_stats'
+          header, *rows = event['stdout'].strip.lines.map(&:chomp)
+          @outputs.keys.select { |key| key.is_a? String }.each do |host|
+            line = rows.find { |row| row =~ /#{host}/ }
+            publish_data_for(host, [header, line].join("\n"), 'stdout')
+          end
+        else
+          broadcast_data(event['stdout'] + "\n", 'stdout')
+        end
+      end
+
+      def write_inventory
+        path = File.join(@root, 'inventory', 'hosts')
+        data_path = File.join(@root, 'data')
+        inventory_script = <<~INVENTORY_SCRIPT
+          #!/bin/sh
+          cat #{::Shellwords.escape data_path}
+        INVENTORY_SCRIPT
+        File.write(path, inventory_script)
+        File.write(data_path, JSON.dump(@inventory))
+        File.chmod(0o0755, path)
+      end
+
+      def write_playbook
+        File.write(File.join(@root, 'project', 'playbook.yml'), @playbook)
+      end
+
+      def start_ansible_runner
+        env = {}
+        env['FOREMAN_CALLBACK_DISABLE'] = '1' if @rex_command
+        command = [env, 'ansible-runner', 'run', @root, '-p', 'playbook.yml']
+        command << '--cmdline' << cmdline unless cmdline.nil?
+        command << verbosity if verbose?
+        initialize_command(*command)
+        logger.debug("[foreman_ansible] - Running command '#{command.join(' ')}'")
+      end
+
+      def cmdline
+        cmd_args = [tags_cmd, check_cmd].reject(&:empty?)
+        return nil unless cmd_args.any?
+        cmd_args.join(' ')
+      end
+
+      def tags_cmd
+        flag = @tags_flag == 'include' ? '--tags' : '--skip-tags'
+        @tags.empty? ? '' : "#{flag} '#{Array(@tags).join(',')}'"
+      end
+
+      def check_cmd
+        check_mode? ? '--check' : ''
+      end
+
+      def verbosity
+        '-' + 'v' * @verbosity_level.to_i
+      end
+
+      def verbose?
+        @verbosity_level.to_i.positive?
+      end
+
+      def check_mode?
+        @check_mode == true
+      end
+
+      def prepare_directory_structure
+        inner = %w[inventory project].map { |part| File.join(@root, part) }
+        ([@root] + inner).each do |path|
+          FileUtils.mkdir_p path
+        end
+      end
+
+      def log_event(description, event)
+        # TODO: replace this ugly code with block variant once https://github.com/Dynflow/dynflow/pull/323
+        # arrives in production
+        logger.debug("[foreman_ansible] - handling event #{description}: #{JSON.pretty_generate(event)}") if logger.level <= ::Logger::DEBUG
+      end
+
+      # Each per-host task has inventory only for itself, we must
+      # collect all the partial inventories into one large inventory
+      # containing all the hosts.
+      def rebuild_inventory(input)
+        action_inputs = input.values.map { |hash| hash[:input][:action_input] }
+        hostnames = action_inputs.map { |hash| hash[:name] }
+        inventories = action_inputs.map { |hash| hash[:ansible_inventory] }
+        host_vars = inventories.map { |i| i['_meta']['hostvars'] }.reduce({}) do |acc, hosts|
+          hosts.reduce(acc) do |inner_acc, (hostname, vars)|
+            vars[:ansible_ssh_private_key_file] ||= Proxy::RemoteExecution::Ssh::Plugin.settings[:ssh_identity_key_file]
+            inner_acc.merge(hostname => vars)
+          end
+        end
+
+        { '_meta' => { 'hostvars' => host_vars },
+          'all' => { 'hosts' => hostnames,
+                     'vars' => inventories.first['all']['vars'] } }
+      end
+
+      def working_dir
+        return @root if @root
+        dir = Proxy::Ansible::Plugin.settings[:working_dir]
+        @tmp_working_dir = true
+        if dir.nil?
+          Dir.mktmpdir
+        else
+          Dir.mktmpdir(nil, File.expand_path(dir))
+        end
+      end
+
+      def rebuild_secrets(inventory, input)
+        input.each do |host, host_input|
+          secrets = host_input['input']['action_input']['secrets']
+          per_host = secrets['per-host'][host]
+
+          new_secrets = {
+            'ansible_password' => inventory['ssh_password'] || per_host['ansible_password'],
+            'ansible_become_password' => inventory['effective_user_password'] || per_host['ansible_become_password']
+          }
+          inventory['_meta']['hostvars'][host].update(new_secrets)
+        end
+
+        inventory
+      end
+    end
+  end
+end

data/lib/smart_proxy_ansible/runner/command_creator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Proxy::Ansible
+  # Creates the actual command to be passed to smart_proxy_dynflow to run
+  class CommandCreator
+    def initialize(inventory_file, playbook_file, options = {})
+      @options = options
+      @playbook_file = playbook_file
+      @inventory_file = inventory_file
+      command
+    end
+
+    def command
+      parts = [environment_variables]
+      parts << 'ansible-playbook'
+      parts.concat(command_options)
+      parts << @playbook_file
+      parts
+    end
+
+    private
+
+    def environment_variables
+      defaults = { 'JSON_INVENTORY_FILE' => @inventory_file }
+      defaults['ANSIBLE_CALLBACK_WHITELIST'] = '' if rex_command?
+      defaults
+    end
+
+    def command_options
+      opts = ['-i', json_inventory_script]
+      opts.concat([setup_verbosity]) if verbose?
+      opts.concat(['-T', @options[:timeout]]) unless @options[:timeout].nil?
+      opts
+    end
+
+    def json_inventory_script
+      File.expand_path('../../../bin/json_inventory.sh', File.dirname(__FILE__))
+    end
+
+    def setup_verbosity
+      verbosity_level = @options[:verbosity_level].to_i
+      verbosity = '-'
+      verbosity_level.times do
+        verbosity += 'v'
+      end
+      verbosity
+    end
+
+    def verbose?
+      verbosity_level = @options[:verbosity_level]
+      # rubocop:disable Rails/Present
+      !verbosity_level.nil? && !verbosity_level.empty? &&
+        verbosity_level.to_i.positive?
+      # rubocop:enable Rails/Present
+    end
+
+    def rex_command?
+      @options[:remote_execution_command]
+    end
+  end
+end

data/lib/smart_proxy_ansible/runner/playbook.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'smart_proxy_dynflow/continuous_output'
+require 'smart_proxy_dynflow/runner/command_runner'
+require_relative 'command_creator'
+require 'tmpdir'
+require 'net/ssh'
+
+module Proxy::Ansible
+  module Runner
+    # Implements Proxy::Dynflow::Runner::Base interface for running
+    # Ansible playbooks, used by the Foreman Ansible plugin and Ansible proxy
+    class Playbook < Proxy::Dynflow::Runner::CommandRunner
+      attr_reader :command_out, :command_in, :command_pid
+
+      def initialize(inventory, playbook, options = {}, suspended_action:)
+        super :suspended_action => suspended_action
+        @inventory = rebuild_secrets(inventory, options[:secrets])
+        unknown_hosts.each do |host|
+          add_to_known_hosts(host)
+        end
+        @playbook  = playbook
+        @options   = options
+        initialize_dirs
+      end
+
+      def start
+        write_inventory
+        write_playbook
+        command = CommandCreator.new(inventory_file,
+                                     playbook_file,
+                                     @options).command
+        logger.debug('[foreman_ansible] - Initializing Ansible Runner')
+        Dir.chdir(@ansible_dir) do
+          initialize_command(*command)
+          logger.debug("[foreman_ansible] - Running command '#{command.join(' ')}'")
+        end
+      end
+
+      def kill
+        publish_data('== TASK ABORTED BY USER ==', 'stdout')
+        publish_exit_status(1)
+        ::Process.kill('SIGTERM', @command_pid)
+        close
+      end
+
+      def close
+        super
+        FileUtils.remove_entry(@working_dir) if @tmp_working_dir
+      end
+
+      private
+
+      def write_inventory
+        ensure_directory(File.dirname(inventory_file))
+        File.write(inventory_file, JSON.dump(@inventory))
+      end
+
+      def write_playbook
+        ensure_directory(File.dirname(playbook_file))
+        File.write(playbook_file, @playbook)
+      end
+
+      def inventory_file
+        File.join(@working_dir, 'foreman-inventories', id)
+      end
+
+      def playbook_file
+        File.join(@working_dir, "foreman-playbook-#{id}.yml")
+      end
+
+      def events_dir
+        File.join(@working_dir, 'events', id.to_s)
+      end
+
+      def ensure_directory(path)
+        if File.exist?(path)
+          raise "#{path} expected to be a directory" unless File.directory?(path)
+        else
+          FileUtils.mkdir_p(path)
+        end
+        path
+      end
+
+      def initialize_dirs
+        settings = Proxy::Ansible::Plugin.settings
+        initialize_working_dir(settings[:working_dir])
+        initialize_ansible_dir(settings[:ansible_dir])
+      end
+
+      def initialize_working_dir(working_dir)
+        if working_dir.nil?
+          @working_dir = Dir.mktmpdir
+          @tmp_working_dir = true
+        else
+          @working_dir = File.expand_path(working_dir)
+        end
+      end
+
+      def initialize_ansible_dir(ansible_dir)
+        raise "Ansible dir #{ansible_dir} does not exist" unless
+          !ansible_dir.nil? && File.exist?(ansible_dir)
+        @ansible_dir = ansible_dir
+      end
+
+      def unknown_hosts
+        @inventory['all']['hosts'].select do |host|
+          Net::SSH::KnownHosts.search_for(host).empty?
+        end
+      end
+
+      def add_to_known_hosts(host)
+        logger.warn("[foreman_ansible] - Host #{host} not found in known_hosts")
+        Net::SSH::Transport::Session.new(host).host_keys.each do |host_key|
+          Net::SSH::KnownHosts.add(host, host_key)
+        end
+        logger.warn("[foreman_ansible] - Added host key #{host} to known_hosts")
+      rescue StandardError => e
+        logger.error('[foreman_ansible] - Failed to save host key for '\
+          "#{host}: #{e}")
+      end
+
+      def rebuild_secrets(inventory, secrets)
+        inventory['all']['hosts'].each do |name|
+          per_host = secrets['per-host'][name]
+
+          new_secrets = {
+            'ansible_password' => inventory['ssh_password'] || per_host['ansible_password'],
+            'ansible_become_password' => inventory['effective_user_password'] || per_host['ansible_become_password']
+          }
+          inventory['_meta']['hostvars'][name].update(new_secrets)
+        end
+
+        inventory
+      end
+    end
+  end
+end

data/lib/smart_proxy_ansible/task_launcher/ansible_runner.rb

@@ -0,0 +1,48 @@
+require 'fileutils'
+require 'smart_proxy_dynflow/task_launcher/abstract'
+require 'smart_proxy_dynflow/task_launcher/batch'
+require 'smart_proxy_dynflow/task_launcher/group'
+require 'smart_proxy_ansible/runner/ansible_runner'
+
+module Proxy::Ansible
+  module TaskLauncher
+    class AnsibleRunner < Proxy::Dynflow::TaskLauncher::AbstractGroup
+      def runner_input(input)
+        super(input).reduce({}) do |acc, (_id, data)|
+          acc.merge(data[:input]['action_input']['name'] => data)
+        end
+      end
+
+      def operation
+        'ansible-runner'
+      end
+
+      def self.runner_class
+        Runner::AnsibleRunner
+      end
+
+      # Discard everything apart from hostname to be able to tell the actions
+      # apart when debugging
+      def transform_input(input)
+        { 'action_input' => input['action_input'].slice('name') }
+      end
+
+      # def self.input_format
+      #   {
+      #     $UUID => {
+      #       :execution_plan_id => $EXECUTION_PLAN_UUID,
+      #       :run_step_id => Integer,
+      #       :input => {
+      #         :action_class => Class,
+      #         :action_input => {
+      #           "ansible_inventory"=> String,
+      #           "hostname"=>"127.0.0.1",
+      #           "script"=>"---\n- hosts: all\n  tasks:\n    - shell: |\n        true\n      register: out\n    - debug: var=out"
+      #         }
+      #       }
+      #     }
+      #   }
+      # end
+    end
+  end
+end

data/lib/smart_proxy_ansible/task_launcher/playbook.rb

@@ -0,0 +1,25 @@
+require 'smart_proxy_dynflow/action/runner'
+
+module Proxy::Ansible
+  module TaskLauncher
+    class Playbook < Proxy::Dynflow::TaskLauncher::Batch
+      class PlaybookRunnerAction < Proxy::Dynflow::Action::Runner
+        def initiate_runner
+          additional_options = {
+            :step_id => run_step_id,
+            :uuid => execution_plan_id
+          }
+          ::Proxy::Ansible::RemoteExecutionCore::AnsibleRunner.new(
+            input.merge(additional_options),
+            :suspended_action => suspended_action
+          )
+        end
+      end
+
+      def child_launcher(parent)
+        ::Proxy::Dynflow::TaskLauncher::Single.new(world, callback, :parent => parent,
+                                                                    :action_class_override => PlaybookRunnerAction)
+      end
+    end
+  end
+end

data/lib/smart_proxy_ansible/version.rb

@@ -2,6 +2,6 @@ module Proxy
   # Version, this allows the proxy and other plugins know
   # what version of the Ansible plugin is running
   module Ansible
-    VERSION = '3.1.1'
+    VERSION = '3.2.0'
   end
 end

data/settings.d/ansible.yml.example

@@ -1,3 +1,3 @@
 ---
 :enabled: true
-:ansible_working_dir: '~/.foreman-ansible'
+:working_dir: '~/.foreman-ansible'

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_ansible
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Ivan Nečas
 - Daniel Lobato
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-09 00:00:00.000000000 Z
+date: 2021-06-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -95,20 +95,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: smart_proxy_dynflow
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: smart_proxy_remote_execution_ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.4'
 description: "    Smart-Proxy ansible plugin\n"
 email:
 - inecas@redhat.com
@@ -123,11 +151,18 @@ files:
 - README.md
 - bundler.d/ansible.rb
 - lib/smart_proxy_ansible.rb
+- lib/smart_proxy_ansible/actions.rb
 - lib/smart_proxy_ansible/api.rb
 - lib/smart_proxy_ansible/exception.rb
 - lib/smart_proxy_ansible/http_config.ru
 - lib/smart_proxy_ansible/plugin.rb
+- lib/smart_proxy_ansible/remote_execution_core/ansible_runner.rb
 - lib/smart_proxy_ansible/roles_reader.rb
+- lib/smart_proxy_ansible/runner/ansible_runner.rb
+- lib/smart_proxy_ansible/runner/command_creator.rb
+- lib/smart_proxy_ansible/runner/playbook.rb
+- lib/smart_proxy_ansible/task_launcher/ansible_runner.rb
+- lib/smart_proxy_ansible/task_launcher/playbook.rb
 - lib/smart_proxy_ansible/variables_extractor.rb
 - lib/smart_proxy_ansible/version.rb
 - settings.d/ansible.yml.example
@@ -135,7 +170,7 @@ homepage: https://github.com/theforeman/smart_proxy_ansible
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -151,7 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Smart-Proxy Ansible plugin
 test_files: []