foreman_acd 0.4.0 → 0.9.0

data/app/controllers/foreman_acd/app_definitions_controller.rb

@@ -9,7 +9,7 @@ module ForemanAcd
     before_action :find_resource, :only => [:edit, :update, :destroy, :export]
     before_action :read_hostgroups, :only => [:edit, :new, :import]
     before_action :read_ansible_playbooks, :only => [:edit, :new]
-    before_action :handle_file_upload, :only => [:create]
+    before_action :assign_ansible_playbook, :only => [:create]
 
     def index
       @app_definitions = resource_base.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page])
@@ -17,7 +17,7 @@ module ForemanAcd
 
     def read_ansible_playbooks
       # Only use ansible playbooks for which the user pressed import group vars once.
-      @ansible_playbooks = AnsiblePlaybook.where.not(vars: nil).map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
+      @ansible_playbooks = AnsiblePlaybook.where.not(:vars => nil).map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
     end
 
     def read_hostgroups
@@ -30,18 +30,24 @@ module ForemanAcd
 
     def create
       @app_definition = AppDefinition.new(app_definition_params)
-      if @app_definition.save
-        process_success
-      else
-        process_error
+      begin
+        if @app_definition.save!
+          process_success
+        else
+          process_error
+        end
+      rescue StandardError, ValidationError => e
+        if params[:foreman_acd_app_definition_import].present?
+          AnsiblePlaybook.find(params[:foreman_acd_app_definition][:acd_ansible_playbook_id]).delete if params[:foreman_acd_app_definition][:acd_ansible_playbook_id].present?
+        end
+        redirect_to new_app_definition_path, :flash => { :error => _(e.message) }
       end
     end
 
-    def edit
-    end
+    def edit; end
 
     def update
-      if @app_definition.update_attributes(app_definition_params)
+      if @app_definition.update(app_definition_params)
         process_success
       else
         process_error
@@ -60,6 +66,8 @@ module ForemanAcd
       case params[:action]
       when 'export'
         :export
+      when 'import'
+        :import
       else
         super
       end
@@ -70,16 +78,110 @@ module ForemanAcd
     end
 
     def export
-      filename = "#{@app_definition.name}.yaml"
-      data = JSON.parse(@app_definition.services).to_yaml
-      send_data data, :type => 'text/yaml', :disposition => 'attachment', :filename => filename
+      dir_path = "#{Dir.mktmpdir}/#{@app_definition.name}.tar"
+      `tar -cvf "#{dir_path}" "#{@app_definition.ansible_playbook.path}" #{export_app_template_data.path}`
+      logger.info("Successfully created application template tar file for #{@app_definition.name}")
+      send_file dir_path
+    rescue StandardError => e
+      logger.info("Export of #{@app_definition.name} failed with the error: #{e}")
+      redirect_to app_definitions_path, :flash => { :error => _(e.message) }
+    end
+
+    def handle_file_upload
+      return unless params[:app_definition_file] && (raw_directory = params[:app_definition_file])
+      begin
+        dir = Dir.mktmpdir
+        untar_import_directory(raw_directory, dir)
+        ansible_file = Dir.glob("#{dir}/tmp/*.yaml")
+        data = JSON.parse(YAML.load_file(ansible_file[0]).to_json) if ansible_file
+        ansible_playbook_import = data.find { |d| d if d['ansible_playbook'] }
+
+        session[:ansible_playbook_params] = { :dir => dir, :ansible_playbook => ansible_playbook_import['ansible_playbook'] }
+        render :json => { :ansible_services => create_ansible_services(data, ansible_playbook_import) }, :status => :ok
+      rescue StandardError => e
+        render :json => { :status => 'error', :message => e }, :status => :internal_server_error
+      end
     end
 
     private
 
-    def handle_file_upload
-      return unless params[:foreman_acd_app_definition] && raw_file = params[:foreman_acd_app_definition][:app_definition_file]
-      params[:foreman_acd_app_definition][:services] = YAML.load_file(raw_file.tempfile).to_json
+    def export_app_template_data
+      file = Tempfile.open([@app_definition.name, '.yaml'])
+      data = JSON.parse(@app_definition.services).append(:ansible_playbook => @app_definition.ansible_playbook.attributes.except('id', 'created_at', 'updated_at').as_json).to_yaml
+      file.write(data)
+      file.close
+      logger.info("Successfully created yaml file for app_template data: #{file.path}")
+      file
+    rescue StandardError => e
+      logger.info("Creation of app template data failed: #{e}")
+      redirect_to app_definitions_path, :flash => { :error => _(e.message) }
+    end
+
+    def rename_path_name(dir_path)
+      return dir_path unless Dir.exist?(dir_path)
+      ind = 1
+      loop do
+        path = dir_path
+        path += ind.to_s
+        return path unless Dir.exist?(path)
+        ind += 1
+      end
+    end
+
+    def create_ansible_playbook(dir, ansible_playbook, dir_path)
+      FileUtils.cp_r "#{dir}/#{ansible_playbook['path']}/.", dir_path
+      ansible_playbook['path'] = dir_path
+      ansible_playbook['name'] = File.basename(dir_path)
+      new_playbook = AnsiblePlaybook.create(ansible_playbook)
+      new_playbook
+    rescue StandardError => e
+      logger.info("Error while creating AnsiblePlaybook: #{e}")
+    end
+
+    def create_ansible_services(data, ansible_playbook_import)
+      ansible_services = []
+      session[:data_services] = data - [ansible_playbook_import]
+      session[:data_services].each do |d|
+        ansible_services.append({ :id => d['id'], :value => d['name'] })
+      end
+      ansible_services
+    end
+
+    def untar_import_directory(directory, dir)
+      `tar -xvf  #{directory.path} -C #{dir}`
+    rescue StandardError => e
+      logger.info("Failed to untar imported directory: #{e}")
+    end
+
+    def assign_ansible_playbook
+      return unless params[:foreman_acd_app_definition_import]
+      dir_path = "#{ForemanAcd.ansible_playbook_path}/#{session[:ansible_playbook_params][:ansible_playbook]['name'].split(/\W+/).join('_')}"
+
+      # Append path and name of ansible with n + 1 if ansible_playbook with same name or name[n] exists
+      ansible_playbook = create_ansible_playbook(session[:ansible_playbook_params][:dir], session[:ansible_playbook_params][:ansible_playbook], rename_path_name(dir_path))
+      params[:foreman_acd_app_definition][:acd_ansible_playbook_id] = ansible_playbook.id
+
+      begin
+        services = JSON.parse(params[:foreman_acd_app_definition_import][:services])
+        flag = 0
+        session[:data_services].each do |d|
+          hostgroup = services.find { |service| service['name'] == d['name'] }['hostgroup']
+          if hostgroup == ''
+            flag += 1
+            break
+          else
+            d['hostgroup'] = hostgroup
+          end
+        end
+        params[:foreman_acd_app_definition][:services] = session[:data_services].to_json
+      rescue StandardError => e
+        ansible_playbook&.destroy
+        redirect_to({ :action => 'import' }, :error => _("Hostgroups are not configured properly: #{e}"))
+      else
+        ansible_playbook&.destroy
+        redirect_to({ :action => 'import' }, :error => _('Some services are not assigned Hostgroups')) if flag.positive?
+      end
+      session[:data_services] = nil
     end
   end
 end

data/app/controllers/foreman_acd/app_instances_controller.rb

@@ -3,43 +3,57 @@
 module ForemanAcd
   # Application Instance Controller
   class AppInstancesController < ::ForemanAcd::ApplicationController
-    include Foreman::Controller::AutoCompleteSearch
+    include ::Foreman::Controller::AutoCompleteSearch
     include ::ForemanAcd::Concerns::AppInstanceParameters
+    include ::ForemanAcd::Concerns::AppInstanceMixins
 
-    before_action :find_resource, :only => [:edit, :update, :destroy, :deploy, :report]
+    before_action :find_resource, :only => [:edit, :update, :destroy_with_hosts, :deploy, :report]
     before_action :read_applications, :only => [:new, :edit]
+    before_action :find_taxonomy
+    helper_method :collect_hosts_data
 
     def index
-      @app_instances = resource_base.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page])
+      @app_instances = resource_base.where(:organization => @organization).
+                       where(:location => @location).
+                       search_for(params[:search], :order => params[:order]).paginate(:page => params[:page])
     end
 
     def new
       @app_instance = AppInstance.new
+      @app_instance.organization = @organization
+      @app_instance.location = @location
     end
 
     def create
       @app_instance = AppInstance.new(app_instance_params)
-      if @app_instance.save
-        process_success
-      else
-        process_error
+      begin
+        if @app_instance.save!
+          app_instance_has_foreman_hosts
+          process_success
+        else
+          process_error
+        end
+      rescue StandardError, ValidationError => e
+        redirect_to new_app_instance_path, :flash => { :error => _(e.message) }
       end
     end
 
-    def edit
-    end
+    def edit; end
 
     def update
       if @app_instance.update(app_instance_params)
+        app_instance_has_foreman_hosts
         process_success
       else
         process_error
       end
     end
 
-    def destroy
+    def destroy_with_hosts
+      @app_instance = AppInstance.find(params[:id])
+      @app_instance.clean_hosts_by_id(params[:foreman_host_ids]) if params[:foreman_host_ids]
       if @app_instance.destroy
-        process_success
+        redirect_to app_instances_path, :flash => { :success => _('Successfully deleted %s') % @app_instance }
       else
         process_error
       end
@@ -51,42 +65,102 @@ module ForemanAcd
         :deploy
       when 'report'
         :report
+      when 'destroy_with_hosts'
+        :destroy
       else
         super
       end
     end
 
     def deploy
-      app_deployer = ForemanAcd::AppDeployer.new(@app_instance)
-      app_hosts = app_deployer.deploy
-
-      # save any change to the app_hosts json
-      @app_instance.hosts = app_hosts.to_json
-      @app_instance.save
+      value = false
+      @app_instance.update!({ :last_deploy_task_id => nil,
+                              :initial_configure_task_id => nil })
+      @app_instance.foreman_hosts.each { |f| f.update!(:last_progress_report => nil) }
+      @app_instance.clean_all_hosts if params[:delete_hosts]
+      value = safe_deploy? if params[:safe_deploy]
+      session.delete(:remember_hosts)
+      logger.info('Run async foreman task to deploy hosts')
+      async_task = ForemanTasks.async_task(::Actions::ForemanAcd::DeployAllHosts, @app_instance, value)
+      @app_instance.update!(:last_deploy_task => async_task)
+
+      redirect_to report_app_instance_path, :success => _('Started task to deploy hosts for %s') % @app_instance
+    rescue StandardError => e
+      error_msg = "Error happend while deploying hosts of #{@app_instance}: #{e.message}"
+      logger.error("#{error_msg} - #{e.class}\n#{e.backtrace.join($INPUT_RECORD_SEPARATOR)}")
+      process_error :error_msg => error_msg
+    end
 
-      @deploy_hosts = collect_host_report_data(app_hosts)
+    def safe_deploy?
+      return false if session[:remember_hosts].empty?
+      session[:remember_hosts]
     end
 
     def report
-      app_hosts = JSON.parse(@app_instance.hosts)
-      @report_hosts = collect_host_report_data(app_hosts)
+      @report_hosts = collect_host_report_data(@app_instance)
+      logger.debug("app instance host details: #{@report_hosts.inspect}")
+    end
+
+    def app_instance_has_foreman_hosts
+      hosts = JSON.parse(@app_instance.hosts)
+      session[:remember_hosts] = []
+      hosts.each do |h|
+        if @app_instance.foreman_hosts.where(:hostname => h['hostname']).exists?
+          old_host = @app_instance.foreman_hosts.find_by(:hostname => h['hostname'])
+
+          @app_instance.foreman_hosts.where(:hostname => h['hostname']).
+            update(:service => h['service'], :description => h['description'],
+                   :foremanParameters => JSON.dump(h['foremanParameters']), :ansibleParameters => JSON.dump(h['ansibleParameters']))
+
+          updated_host = @app_instance.foreman_hosts.find_by(:hostname => h['hostname'])
+
+          # Store hosts if updated for safe deploy
+          session[:remember_hosts] << updated_host.id if updated_host.updated_at != old_host.updated_at
+        else
+          @app_instance.foreman_hosts.create(:hostname => h['hostname'],
+                                             :service => h['service'],
+                                             :description => h['description'],
+                                             :is_existing_host => h['isExistingHost'],
+                                             :foremanParameters => JSON.dump(h['foremanParameters']),
+                                             :ansibleParameters => JSON.dump(h['ansibleParameters']))
+          # Store new hosts for safe deploy
+          session[:remember_hosts] << @app_instance.foreman_hosts.find_by(:hostname => h['hostname']).id
+        end
+      end
 
-      logger.debug("deploy report hosts are: #{@report_hosts.inspect}")
+      # Delete record if json hosts are deleted
+      deleted_json_hosts = @app_instance.foreman_hosts.pluck('hostname') - hosts.pluck('hostname')
+      @app_instance.foreman_hosts.where(:hostname => deleted_json_hosts).destroy_all if deleted_json_hosts
+    end
+
+    def collect_hosts_data
+      hosts_data = []
+      @app_instance.foreman_hosts.each do |h|
+        hosts_data << {
+          :id => h.id,
+          :hostname => h.hostname,
+          :service => h.service,
+          :description => h.description,
+          :isExistingHost => h.is_existing_host,
+          :foremanParameters => JSON.parse(h.foremanParameters),
+          :ansibleParameters => JSON.parse(h.ansibleParameters)
+        }
+      end
+      hosts_data
     end
 
     private
 
-    def read_applications
-      @applications = AppDefinition.all.map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
+    def find_taxonomy
+      @organization = Organization.current
+      redirect_to '/select_organization?toState=' + request.path and return unless @organization
+
+      @location = Location.current
+      redirect_to root_path, :error => 'Select a location to show App Instances' and return unless @location
     end
 
-    def collect_host_report_data(app_hosts)
-      report_data = []
-      app_hosts.each do |host_data|
-        host = Host.find(host_data['foreman_host_id'])
-        report_data << { id: host.id, name: host_data['hostname'], hostname: host.hostname, hostUrl: host_path(host), progress_report_id: host.progress_report_id}
-      end
-      report_data
+    def read_applications
+      @applications = AppDefinition.all.map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
     end
   end
 end

data/app/controllers/foreman_acd/concerns/ansible_playbook_parameters.rb

@@ -9,7 +9,7 @@ module ForemanAcd
       class_methods do
         def ansible_playbook_params_filter
           Foreman::ParameterFilter.new(::ForemanAcd::AnsiblePlaybook).tap do |filter|
-            filter.permit(:name, :description, :scm_type, :path, :playfile)
+            filter.permit(:name, :description, :scm_type, :path, :git_commit, :git_url, :playfile, :location_ids => [], :organization_ids => [])
           end
         end
       end

data/app/controllers/foreman_acd/concerns/app_definition_parameters.rb

@@ -9,7 +9,7 @@ module ForemanAcd
       class_methods do
         def app_definition_params_filter
           Foreman::ParameterFilter.new(::ForemanAcd::AppDefinition).tap do |filter|
-            filter.permit(:name, :description, :acd_ansible_playbook_id, :services, :ansible_vars_all)
+            filter.permit(:name, :description, :acd_ansible_playbook_id, :services, :ansible_vars_all, :location_ids => [], :organization_ids => [])
           end
         end
       end

data/app/controllers/foreman_acd/concerns/app_instance_mixins.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  module Concerns
+    # Shared code for AppInstance API and UI controller
+    module AppInstanceMixins
+      extend ActiveSupport::Concern
+
+      def collect_host_report_data(app_instance)
+        report_data = []
+
+        app_instance.foreman_hosts.each do |foreman_host|
+          a_host = {
+            :id => nil,
+            :name => foreman_host.hostname,
+            :build => nil,
+            :hostUrl => nil,
+            :progress_report => foreman_host.last_progress_report.empty? ? [] : JSON.parse(foreman_host.last_progress_report)
+          }
+
+          if foreman_host.host.present?
+            a_host.update({
+                            :id => foreman_host.host.id,
+                            :build => foreman_host.host.build,
+                            :hostUrl => host_path(foreman_host.host),
+                            :isExistingHost => foreman_host.is_existing_host,
+                            :powerStatusUrl => power_api_host_path(foreman_host.host)
+                          })
+          end
+          report_data << OpenStruct.new(a_host)
+        end
+        report_data
+      end
+    end
+  end
+end

data/app/controllers/foreman_acd/concerns/app_instance_parameters.rb

@@ -9,7 +9,7 @@ module ForemanAcd
       class_methods do
         def app_instance_params_filter
           Foreman::ParameterFilter.new(::ForemanAcd::AppInstance).tap do |filter|
-            filter.permit(:name, :app_definition_id, :description, :hosts, :ansible_vars_all)
+            filter.permit(:name, :app_definition_id, :description, :hosts, :ansible_vars_all, :organization_id, :location_id)
           end
         end
       end

data/app/controllers/foreman_acd/remote_execution_controller.rb

@@ -3,29 +3,41 @@
 module ForemanAcd
   # Class to run remote execution jobs
   class RemoteExecutionController < JobInvocationsController
-
     def new
-      jobs = init_configuration
-      @composer = jobs.first
+      set_app_instance
+      result, job = init_configuration
+
+      if result.success == true
+        @composer = job
+      else
+        redirect_to(app_instances_path, :error => _("Coult not create remote execution job to configure the app '%{app_instance}': %{msg}") % {
+          :app_instance => @app_instance, :msg => result.error
+        })
+      end
     end
 
     def create
       customize_first = params[:customize] || false
-      jobs = init_configuration
-
-      if jobs.count == 1 && customize_first == false
-        @composer = jobs.first
-        @composer.trigger!
-        redirect_to job_invocation_path(@composer.job_invocation)
-      elsif customize_first == false
-        jobs.each do |composer|
-          composer.trigger
+      begin
+        set_app_instance
+        result, job = init_configuration
+
+        unless result.success == true
+          return redirect_to(app_instances_path, :error => _("Coult not create remote execution job to configure the app '%{app_instance}': %{msg}") % {
+            :app_instance => @app_instance, :msg => result.error
+          })
         end
-        # redirect to the job itself if we want to customize the job
-        redirect_to job_invocations_path
-      else
-        @composer = jobs.first
-        render :action => 'new'
+
+        @composer = job
+        if customize_first == false
+          @composer.trigger!
+          redirect_to job_invocation_path(@composer.job_invocation)
+        else
+          # redirect to the job itself if we want to customize the job
+          render :action => 'new'
+        end
+      rescue StandardError => e
+        redirect_to app_instances_path, :error => _("#{job}, #{e}")
       end
     end
 
@@ -37,13 +49,14 @@ module ForemanAcd
 
     private
 
-    def init_configuration
-      app_instance = ForemanAcd::AppInstance.find_by(:name => params[:id])
-      app_configurator = ForemanAcd::AppConfigurator.new(app_instance)
+    def set_app_instance
+      @app_instance = ForemanAcd::AppInstance.find_by(:id => params[:id])
+    end
 
-      jobs = app_configurator.configure
-      logger.debug("Creating #{jobs.count} job(s) to configure the app #{app_instance}. Customize first: #{params[:customize]}")
-      return jobs
+    def init_configuration
+      logger.debug("Creating job to configure the app #{@app_instance}. Customize first: #{params[:customize]}")
+      app_configurator = ForemanAcd::AppConfigurator.new(@app_instance)
+      app_configurator.configure
     end
   end
 end

data/app/controllers/ui_acd_controller.rb

@@ -2,6 +2,8 @@
 
 # Controller to create JSON data to be used in react app
 class UiAcdController < ::Api::V2::BaseController
+  include ::ForemanAcd::Concerns::AppInstanceMixins
+
   def app
     @app_data = {}
     app_definition = ForemanAcd::AppDefinition.find(params[:id])
@@ -16,6 +18,23 @@ class UiAcdController < ::Api::V2::BaseController
     @ansible_data = collect_ansible_data(params['id'])
   end
 
+  def report_data
+    @report_data = collect_report_data(params['id'])
+  end
+
+  def validate_hostname
+    @host_validation = hostname_duplicate?(params['appDefId'].to_i, params['serviceId'].to_i, params['hostname'])
+  end
+
+  def action_permission
+    case params[:action]
+    when 'app', 'foreman_data', 'ansible_data', 'validate_hostname'
+      :view
+    else
+      super
+    end
+  end
+
   private
 
   def collect_foreman_data(hostgroup_id)
@@ -34,4 +53,31 @@ class UiAcdController < ::Api::V2::BaseController
   def collect_ansible_data(playbook_id)
     ForemanAcd::AnsiblePlaybook.find(playbook_id).as_unified_structobj
   end
+
+  def collect_report_data(app_instance_id)
+    app_instance = ForemanAcd::AppInstance.find(app_instance_id)
+
+    report_data = {
+      :hosts => collect_host_report_data(app_instance),
+      :deploymentState => app_instance.deployment_state.to_s,
+      :initialConfigureState => app_instance.initial_configure_state.to_s
+    }
+    report_data['initialConfigureJobUrl'] = job_invocation_path(app_instance.initial_configure_job) unless app_instance.initial_configure_job.nil?
+
+    OpenStruct.new(report_data)
+  end
+
+  def hostname_duplicate?(app_def_id, service_id, hostname)
+    app_definition = ForemanAcd::AppDefinition.find(app_def_id)
+    service_data = JSON.parse(app_definition.services).select { |k| k['id'] == service_id }.first
+    domain_name = Hostgroup.find(service_data['hostgroup']).domain.name
+    validation_hostname = "#{hostname}.#{domain_name}"
+
+    vdata = OpenStruct.new(
+      :hostname => hostname,
+      :fqdn => validation_hostname,
+      :result => Host.find_by(:name => validation_hostname).nil?
+    )
+    vdata
+  end
 end

data/app/lib/actions/foreman_acd/deploy_all_hosts.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Actions
+  module ForemanAcd
+    # DeployAllHosts implements a Foreman Task EntryAction
+    class DeployAllHosts < Actions::EntryAction
+      def plan(app_instance, safe_deploy)
+        action_subject(app_instance, :safe_deploy => safe_deploy)
+        plan_self(:id => app_instance.id)
+      end
+
+      def run
+        output[:status] = 'IN PROGRESS'
+        app_instance = ::ForemanAcd::AppInstance.find(input.fetch(:id))
+        safe_deploy = input.fetch(:safe_deploy)
+
+        # Goal: all, safe_deploy or nothing
+        begin
+          if safe_deploy
+            ::Foreman::Logging.logger('foreman_acd').info "Start to safe deploy hosts of the app #{app_instance}"
+          else
+            ::Foreman::Logging.logger('foreman_acd').info "Start to deploy all hosts of the app #{app_instance}"
+          end
+          app_deployer = ::ForemanAcd::AppDeployer.new(app_instance)
+          output[:data] = app_deployer.deploy(safe_deploy)
+          output[:status] = 'SUCCESS'
+        rescue StandardError => e
+          ::Foreman::Logging.logger('foreman_acd').error "Error while deploying hosts for application instance '#{app_instance.name}'. Clean up all other hosts: #{e}"
+          app_instance.clean_all_hosts
+
+          output[:status] = 'FAILURE'
+          raise "Error while deploying hosts for application instance '#{app_instance.name}': (#{e.message})"
+        end
+      end
+
+      def finalize; end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Fail
+      end
+
+      def humanized_name
+        _('Deploy application instance hosts')
+      end
+    end
+  end
+end

data/app/lib/actions/foreman_acd/run_configurator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Actions
+  module ForemanAcd
+    # RunConfigurator implements a Foreman Task EntryAction
+    class RunConfigurator < Actions::EntryAction
+      def plan(app_instance)
+        action_subject(app_instance)
+        plan_self(:id => app_instance.id)
+      end
+
+      def run
+        output[:status] = 'SUCCESS'
+        begin
+          app_instance = ::ForemanAcd::AppInstance.find(input.fetch(:id))
+          app_configurator = ::ForemanAcd::AppConfigurator.new(app_instance)
+
+          result, job = app_configurator.configure
+          if result.success
+            ::Foreman::Logging.logger('foreman_acd').info "Creating job to configure the app #{app_instance}"
+            job.trigger!
+            output[:configure_job_id] = job.job_invocation.id
+          else
+            ::Foreman::Logging.logger('foreman_acd').error "Could not create the job to configure the app #{app_instance}: #{result.error}"
+          end
+        rescue StandardError => e
+          ::Foreman::Logging.logger('foreman_acd').error "Error while configuring application instance '#{app_instance.name}': #{e}"
+
+          output[:status] = 'FAILURE'
+          raise "Error while configuring hosts via ansible playbook for application instance '#{app_instance.name}': (#{e.message})"
+        end
+      end
+
+      def finalize; end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Fail
+      end
+
+      def humanized_name
+        _('Configure application instance after hosts deployment')
+      end
+    end
+  end
+end