foreman_acd 0.2.1 → 0.7.0

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  module Concerns
+    # Parameters for AnsiblePlaybooks
+    module AnsiblePlaybookParameters
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def ansible_playbook_params_filter
+          Foreman::ParameterFilter.new(::ForemanAcd::AnsiblePlaybook).tap do |filter|
+            filter.permit(:name, :description, :scm_type, :path, :git_commit, :git_url, :playfile, :location_ids => [], :organization_ids => [])
+          end
+        end
+      end
+
+      def ansible_playbook_params
+        param_name = parameter_filter_context.api? ? 'ansible_playbook' : 'foreman_acd_ansible_playbook'
+        self.class.ansible_playbook_params_filter.filter_params(params, parameter_filter_context, param_name)
+      end
+    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, :services)
+            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_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)
+            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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Class to run remote execution jobs
+  class RemoteExecutionController < JobInvocationsController
+    def new
+      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
+      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
+
+        @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
+
+    # to overcome the isolated namespace engine difficulties with paths
+    helper Rails.application.routes.url_helpers
+    def _routes
+      Rails.application.routes
+    end
+
+    private
+
+    def set_app_instance
+      @app_instance = ForemanAcd::AppInstance.find_by(:id => params[:id])
+    end
+
+    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

@@ -8,13 +8,26 @@ class UiAcdController < ::Api::V2::BaseController
     @app_data['app_definition'] = app_definition
   end
 
-  def fdata
-    @fdata = collect_fdata(params['id'])
+  def foreman_data
+    @foreman_data = collect_foreman_data(params['id'])
+  end
+
+  def ansible_data
+    @ansible_data = collect_ansible_data(params['id'])
+  end
+
+  def action_permission
+    case params[:action]
+    when 'app', 'foreman_data', 'ansible_data'
+      :view
+    else
+      super
+    end
   end
 
   private
 
-  def collect_fdata(hostgroup_id)
+  def collect_foreman_data(hostgroup_id)
     hg = Hostgroup.find(hostgroup_id)
     fdata = OpenStruct.new(
       :environments => Environment.all,
@@ -26,4 +39,8 @@ class UiAcdController < ::Api::V2::BaseController
     )
     fdata
   end
+
+  def collect_ansible_data(playbook_id)
+    ForemanAcd::AnsiblePlaybook.find(playbook_id).as_unified_structobj
+  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,44 @@
+# 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!
+          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

data/app/models/concerns/foreman_acd/host_managed_extensions.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Extends the Host Managed
+  module HostManagedExtensions
+    extend ActiveSupport::Concern
+
+    RUN_CONFIGURATOR_DELAY = 240
+
+    def self.prepended(base)
+      base.instance_eval do
+        before_provision :initiate_acd_app_configurator, :if => :deployed_via_acd?
+      end
+    end
+
+    def deployed_via_acd?
+      find_app_instance_host
+      @app_instance_host.present?
+    end
+
+    private
+
+    def find_app_instance_host
+      @app_instance_host = ForemanAcd::ForemanHost.find_by(:host_id => id)
+    end
+
+    def initiate_acd_app_configurator
+      return false if @app_instance_host.blank?
+
+      run_it = true
+      @app_instance_host.app_instance.foreman_hosts.each do |foreman_host|
+        # if there is ONE host, which is still in build phase we don't let the app_configuator run
+        next unless foreman_host.host.build?
+        ::Foreman::Logging.logger('foreman_acd').info("Another host (#{foreman_host.host.name} is still in build-phase. Wait for it...")
+        run_it = false
+        break
+      end
+
+      return unless run_it
+
+      ::Foreman::Logging.logger('foreman_acd').info("All hosts of app (#{@app_instance_host.app_instance.name}) were built. Schedule app configurator...")
+      start_acd_app_configurator
+    end
+
+    def start_acd_app_configurator
+      ForemanTasks.delay(::Actions::ForemanAcd::RunConfigurator,
+                         { :start_at => Time.zone.now + RUN_CONFIGURATOR_DELAY },
+                         @app_instance_host.app_instance)
+    end
+  end
+end

data/app/models/foreman_acd/acd_provider.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Implement a RemoteExecutionProvider
+  class AcdProvider < ::RemoteExecutionProvider
+    class << self
+      def supports_effective_user?
+        true
+      end
+
+      def proxy_operation_name
+        'acd'
+      end
+
+      def humanized_name
+        'ACD'
+      end
+
+      def proxy_command_options(template_invocation, host)
+        super(template_invocation, host).merge(:name => host.name)
+      end
+
+      def ssh_password(_host); end
+
+      def ssh_key_passphrase(_host); end
+
+      def sudo_password(_host); end
+
+      # Workaround till infrastructure jobs on proxies are possible. See
+      # configure in services/foreman_acd/app_configurator.rb for more details.
+      # def required_proxy_selector_for(_template)
+      #   AcdProxyProxySelector.new
+      # end
+    end
+  end
+end

data/app/models/foreman_acd/ansible_playbook.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Ansible playbook
+  class AnsiblePlaybook < ApplicationRecord
+    include Authorizable
+    include Taxonomix
+    extend FriendlyId
+    friendly_id :name
+    include Parameterizable::ByIdName
+
+    self.table_name = 'acd_ansible_playbooks'
+    has_many :app_definitions, :inverse_of => :ansible_playbook, :foreign_key => 'acd_ansible_playbook_id', :dependent => :restrict_with_error
+    validates :name, :presence => true, :uniqueness => true
+    validates :scm_type, :presence => true
+    scoped_search :on => :name
+
+    default_scope do
+      with_taxonomy_scope do
+        order('acd_ansible_playbooks.name')
+      end
+    end
+
+    def used_location_ids
+      Location.joins(:taxable_taxonomies).where(
+        'taxable_taxonomies.taxable_type' => 'ForemanAcd::AnsiblePlaybook',
+        'taxable_taxonomies.taxable_id' => id
+      ).pluck("#{Taxonomy.table_name}.id")
+    end
+
+    def used_organization_ids
+      Organization.joins(:taxable_taxonomies).where(
+        'taxable_taxonomies.taxable_type' => 'ForemanAcd::AnsiblePlaybook',
+        'taxable_taxonomies.taxable_id' => id
+      ).pluck("#{Taxonomy.table_name}.id")
+    end
+
+    def self.humanize_class_name(_name = nil)
+      _('Ansible playbook')
+    end
+
+    def self.permission_name
+      'ansible_playbooks'
+    end
+
+    def content
+      case scm_type
+      when 'directory' || 'git'
+        File.read(File.join(path, playfile))
+      else
+        raise NotImplementedError.new "scm_type #{scm_type.inspect} not supported!"
+      end
+    end
+
+    def as_unified_structobj
+      # FIXME: For now, we convert all values to string - even booleans and dicts
+      pretty_groups = JSON.parse(vars).each do |_, params|
+        params.transform_values!(&:to_s)
+      end
+
+      OpenStruct.new(
+        :id => id,
+        :name => name,
+        :groups => pretty_groups
+      )
+    end
+  end
+end

data/app/models/foreman_acd/app_definition.rb

@@ -4,13 +4,38 @@ module ForemanAcd
   # Application Definition
   class AppDefinition < ApplicationRecord
     include Authorizable
+    include Taxonomix
     extend FriendlyId
     friendly_id :name
+    include Parameterizable::ByIdName
 
+    self.table_name = 'acd_app_definitions'
     validates :name, :presence => true, :uniqueness => true
+    validates :ansible_playbook, :presence => true
     has_many :app_instances, :inverse_of => :app_definition, :dependent => :destroy
+    belongs_to :ansible_playbook, :inverse_of => :app_definitions, :foreign_key => :acd_ansible_playbook_id
     scoped_search :on => :name
 
+    default_scope do
+      with_taxonomy_scope do
+        order('acd_app_definitions.name')
+      end
+    end
+
+    def used_location_ids
+      Location.joins(:taxable_taxonomies).where(
+        'taxable_taxonomies.taxable_type' => 'ForemanAcd::AppDefinition',
+        'taxable_taxonomies.taxable_id' => id
+      ).pluck("#{Taxonomy.table_name}.id")
+    end
+
+    def used_organization_ids
+      Organization.joins(:taxable_taxonomies).where(
+        'taxable_taxonomies.taxable_type' => 'ForemanAcd::AppDefinition',
+        'taxable_taxonomies.taxable_id' => id
+      ).pluck("#{Taxonomy.table_name}.id")
+    end
+
     def self.humanize_class_name(_name = nil)
       _('App Definition')
     end

data/app/models/foreman_acd/app_instance.rb

@@ -4,11 +4,24 @@ module ForemanAcd
   # Application Instance
   class AppInstance < ApplicationRecord
     include Authorizable
+    include ForemanTasks::Concerns::ActionSubject
     extend FriendlyId
     friendly_id :name
+    include Parameterizable::ByIdName
+
+    self.table_name = 'acd_app_instances'
+    belongs_to :last_deploy_task, :class_name => 'ForemanTasks::Task'
     validates :name, :presence => true, :uniqueness => true
+    validates :app_definition, :presence => true
     belongs_to :app_definition, :inverse_of => :app_instances
+    belongs_to :organization
+    validates :organization, :presence => true
+    belongs_to :location
+    validates :location, :presence => true
+    has_many :foreman_hosts, :inverse_of => :app_instance, :dependent => :destroy
     scoped_search :on => :name
+    default_scope -> { order('acd_app_instances.name') }
+    attr_accessor :hosts
 
     def self.humanize_class_name(_name = nil)
       _('App Instance')
@@ -17,5 +30,34 @@ module ForemanAcd
     def self.permission_name
       'app_instances'
     end
+
+    def clean_all_hosts
+      remember_host_ids = foreman_hosts.map(&:host_id)
+
+      # Clean the app instance association first
+      foreman_hosts.update_all(:host_id => nil)
+
+      # Remove all hosts afterwards
+      delete_hosts(remember_host_ids)
+    end
+
+    def clean_hosts_by_id(ids = [])
+      # Clean the app instance association first
+      foreman_hosts.where(:host_id => ids).update_all(:host_id => nil)
+
+      # Remove all hosts afterwards
+      delete_hosts(ids)
+    end
+
+    def delete_hosts(ids = [])
+      return if ids.empty?
+      ids.each do |host_id|
+        h = ::Host.find(host_id) unless host_id.nil?
+        if h
+          Katello::RegistrationManager.unregister_host(h, :unregistering => false) if ForemanAcd.with_katello?
+          h.destroy
+        end
+      end
+    end
   end
 end