foreman_acd 0.0.6 → 0.6.0

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Actions
+  module ForemanAcd
+    # DeployAllHosts implements a Foreman Task EntryAction
+    class DeployAllHosts < Actions::EntryAction
+      def plan(app_instance)
+        action_subject(app_instance)
+        plan_self(:id => app_instance.id)
+      end
+
+      def run
+        output[:status] = 'IN PROGRESS'
+        app_instance = ::ForemanAcd::AppInstance.find(input.fetch(:id))
+
+        # Goal: all or nothing
+        begin
+          ::Foreman::Logging.logger('foreman_acd').info "Start to deploy all hosts of the app #{app_instance}"
+          app_deployer = ::ForemanAcd::AppDeployer.new(app_instance)
+          output[:data] = app_deployer.deploy
+          output[:status] = 'SUCCESS'
+        rescue StandardError => e
+          ::Foreman::Logging.logger('foreman_acd').error "Error while deploying hosts for application instance. Clean up all other hosts: #{e}"
+          app_instance.clean_all_hosts
+
+          output[:error] = e.to_s
+          output[:status] = 'FAILURE'
+        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,41 @@
+# 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)
+
+          jobs = app_configurator.configure
+          ::Foreman::Logging.logger('foreman_acd').info "Creating #{jobs.count} job(s) to configure the app #{app_instance}"
+
+          # TODO: would it be better to create a sub task for each job we need to run?
+          jobs.each(&:trigger)
+        rescue StandardError => e
+          ::Foreman::Logging.logger('foreman_acd').error "Error while configuring application instance: #{e}"
+          output[:error] = e.to_s
+          output[:status] = 'FAILURE'
+        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
+
+    private
+
+    def deployed_via_acd?
+      find_app_instance_host
+      @app_instance_host.present?
+    end
+
+    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,30 @@
+# 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
+    end
+  end
+end

data/app/models/foreman_acd/ansible_playbook.rb

@@ -0,0 +1,67 @@
+# 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
+    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'
+        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,14 +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
-    belongs_to :hostgroup, :class_name => '::Hostgroup'
+    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::Engine.with_katello?
+          h.destroy
+        end
+      end
+    end
   end
 end

data/app/models/foreman_acd/foreman_host.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Foreman Host
+  class ForemanHost < ApplicationRecord
+    include Authorizable
+
+    self.table_name = 'acd_foreman_hosts'
+    validates :hostname, :presence => true
+    belongs_to :app_instance, :inverse_of => :foreman_hosts
+    belongs_to :host, :class_name => '::Host::Managed'
+    scoped_search :on => :hostname
+    default_scope -> { order('acd_foreman_hosts.hostname') }
+
+    def self.humanize_class_name(_name = nil)
+      _('Foreman Host')
+    end
+
+    def self.permission_name
+      'foreman_hosts'
+    end
+  end
+end

data/app/models/foreman_acd/taxonomy_extensions.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # This is a TaxonomyExtensions
+  module TaxonomyExtensions
+    extend ActiveSupport::Concern
+
+    included do
+      if SETTINGS[:version].to_s.to_f <= 1.7
+        def self.enabled_taxonomies
+          %w[locations organizations].select { |taxonomy| SETTINGS["#{taxonomy}_enabled".to_sym] }
+        end
+      end
+    end
+  end
+end
+# To be removed after 1.7 compatibility is no longer required

data/app/services/foreman_acd/app_configurator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # application instances configurator
+  class AppConfigurator
+    delegate :logger, :to => :Rails
+
+    def initialize(app_instance)
+      @app_instance = app_instance
+    end
+
+    def configure
+      job_input = {}
+      job_input['application_name'] = @app_instance.name
+      job_input['playbook_id'] = @app_instance.app_definition.ansible_playbook.id
+      job_input['playbook_file'] = @app_instance.app_definition.ansible_playbook.playfile
+
+      logger.info("Use inventory to configure #{@app_instance.name} with ansible playbook #{@app_instance.app_definition.ansible_playbook.name}")
+
+      begin
+        proxy_hosts = {}
+        jobs = []
+
+        hosts = @app_instance.foreman_hosts
+        proxy_selector = RemoteExecutionProxySelector.new
+        hosts.each do |h|
+          proxy = proxy_selector.determine_proxy(h.host, 'ACD')
+          proxy_hosts[proxy.name] = [] unless proxy_hosts.key?(proxy.name)
+          proxy_hosts[proxy.name] << h
+        end
+
+        # TODO: just for testing...
+        # proxy_hosts = { Host.first.name => [ Host.first.id] }
+
+        # we need to compose multiple jobs. for each proxy one job.
+        proxy_hosts.each do |proxy_name, foreman_hosts|
+          # create the inventory file
+          inventory = ForemanAcd::InventoryCreator.new(@app_instance, foreman_hosts).create_inventory
+          job_input['inventory'] = YAML.dump(inventory)
+
+          composer = JobInvocationComposer.for_feature(
+            :run_acd_ansible_playbook,
+            [Host.find_by(:name => proxy_name).id],
+            job_input.to_hash
+          )
+          jobs << composer
+        end
+      rescue StandardError => e
+        logger.error("Failed to configure hosts: #{e.class}: #{e.message}\n#{e.backtrace.join($INPUT_RECORD_SEPARATOR)}")
+      end
+      jobs
+    end
+  end
+end

data/app/services/foreman_acd/app_deployer.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # application instances deployer
+  class AppDeployer
+    delegate :logger, :to => :Rails
+
+    def initialize(app_instance)
+      @app_instance = app_instance
+    end
+
+    def deploy
+      output = []
+      services = JSON.parse(@app_instance.app_definition.services)
+      all_hosts = []
+
+      @app_instance.foreman_hosts.each do |foreman_host|
+        service_data = services.select { |k| k['id'] == foreman_host.service.to_i }.first
+        host_params = set_host_params(foreman_host, service_data)
+
+        host = foreman_host.host.presence
+
+        is_rebuild = false
+
+        if host.blank?
+          params = host_attributes(host_params)
+          log_params = params.dup
+          log_params['root_pass'] = '****' if log_params.key?('root_pass')
+          msg = "Host creation parameters for #{foreman_host.hostname}:\n#{log_params}\n"
+          logger.info(msg)
+          output << msg
+          host = Host.new(params)
+        else
+          msg = "Update parameters and re-deploy host #{foreman_host.hostname}"
+          logger.info(msg)
+          output << msg
+          host.attributes = host_attributes(host_params, host)
+          is_rebuild = true
+        end
+
+        # REMOVE ME (but very nice for testing)
+        # host.mac = "00:11:22:33:44:55"
+
+        apply_compute_profile(host)
+        host.suggest_default_pxe_loader
+
+        all_hosts << OpenStruct.new(:foreman_host => foreman_host, :host => host, :rebuild => is_rebuild)
+      end
+
+      # do this in a second step, so that we get the progress report for all
+      all_hosts.each do |os_host|
+        # Save the host -> will initiate the deployment
+        os_host.host.save!
+        msg = "Saved and initiated/updated host #{os_host.foreman_host.hostname}"
+        logger.info(msg)
+        output << msg
+
+        os_host.host.power.reset if os_host.rebuild
+
+        # save the foreman host id
+        os_host.foreman_host.update!(:host_id => os_host.host.id)
+
+        progress_report = Rails.cache.fetch(os_host.host.progress_report_id)
+        os_host.foreman_host.update!(:last_progress_report => progress_report)
+        if progress_report.empty?
+          msg = "Progress report for #{os_host.foreman_host.hostname} is empty!"
+          output << msg
+        end
+      end
+      output
+    end
+
+    private
+
+    # Copied from foreman/app/controllers/api/v2/hosts_controller.rb
+    def apply_compute_profile(host)
+      host.apply_compute_profile(InterfaceMerge.new(:merge_compute_attributes => true))
+      host.apply_compute_profile(ComputeAttributeMerge.new)
+    end
+
+    # Copied from foreman/app/controllers/api/v2/hosts_controller.rb
+    def host_attributes(params, host = nil)
+      return {} if params.nil?
+
+      params = params.deep_clone
+      if params[:interfaces_attributes]
+        # handle both hash and array styles of nested attributes
+        params[:interfaces_attributes] = params[:interfaces_attributes].values if params[:interfaces_attributes].is_a?(Hash) || params[:interfaces_attributes].is_a?(ActionController::Parameters)
+        # map interface types
+        params[:interfaces_attributes] = params[:interfaces_attributes].map do |nic_attr|
+          interface_attributes(nic_attr, :allow_nil_type => host.nil?)
+        end
+      end
+      params = host.apply_inherited_attributes(params) if host
+      params
+    end
+
+    # Copied from foreman/app/controllers/api/v2/hosts_controller.rb
+    def interface_attributes(params, allow_nil_type: false)
+      params[:type] = InterfaceTypeMapper.map(params[:type]) if params.key?(:type) || allow_nil_type
+      params
+    end
+
+    def hardcoded_params
+      result = {}
+      result['build'] = true
+      result['compute_attributes'] = { 'start' => '1' }
+      result['enabled'] = true
+      result['host_parameters_attributes'] = []
+      result['managed'] = true
+      result
+    end
+
+    def set_host_params(foreman_host, service_data)
+      result = hardcoded_params
+      result['name'] = foreman_host.hostname
+      result['hostgroup_id'] = service_data['hostgroup']
+
+      JSON.parse(foreman_host.foremanParameters).each do |param|
+        case param['type']
+
+        when 'computeprofile'
+          result['compute_profile_id'] = param['value']
+
+        when 'domain'
+          result['domain_id'] = param['value']
+
+        when 'hostparam'
+          result['host_parameters_attributes'].push(:name => param['name'], :value => param['value'])
+
+        when 'ip'
+          result['ip'] = param['value']
+
+        when 'lifecycleenv'
+          result['content_facet_attributes'] = { 'lifecycle_environment_id' => param['value'] }
+
+        when 'ptable'
+          result['ptable_id'] = param['value']
+
+        when 'puppetenv'
+          result['environment_id'] = param['value']
+
+        when 'password'
+          result['root_pass'] = param['value']
+
+        end
+      end
+      result
+    end
+  end
+end