foreman_acd 0.0.4 → 0.4.0

data/app/controllers/foreman_acd/app_instances_controller.rb

@@ -6,19 +6,15 @@ module ForemanAcd
     include Foreman::Controller::AutoCompleteSearch
     include ::ForemanAcd::Concerns::AppInstanceParameters
 
-    before_action :find_resource, :only => [:edit, :update, :destroy, :deploy]
+    before_action :find_resource, :only => [:edit, :update, :destroy, :deploy, :report]
+    before_action :read_applications, :only => [:new, :edit]
 
     def index
       @app_instances = resource_base.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page])
     end
 
-    def read_applications
-      @applications = ForemanAcd::AppDefinition.all.map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
-    end
-
     def new
       @app_instance = AppInstance.new
-      read_applications
     end
 
     def create
@@ -31,7 +27,6 @@ module ForemanAcd
     end
 
     def edit
-      read_applications
     end
 
     def update
@@ -54,105 +49,44 @@ module ForemanAcd
       case params[:action]
       when 'deploy'
         :deploy
+      when 'report'
+        :report
       else
         super
       end
     end
 
     def deploy
-      params = host_attributes(set_host_params)
-
-      # Print to log for debugging purposes
-      logger.info("Host creation parameters:\n#{params}\n")
-
-      @host = Host.new(params)
-      apply_compute_profile(@host)
-      @host.suggest_default_pxe_loader
-      @host.save
-      success _('Successfully initiated host creation')
-    rescue StandardError => e
-      logger.error("Failed to initiate host creation: #{e.backtrace.join($INPUT_RECORD_SEPARATOR)}")
-    ensure
-      redirect_to app_instances_path
-    end
-
-    private
+      app_deployer = ForemanAcd::AppDeployer.new(@app_instance)
+      app_hosts = app_deployer.deploy
 
-    # 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
+      # save any change to the app_hosts json
+      @app_instance.hosts = app_hosts.to_json
+      @app_instance.save
 
-    # 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
+      @deploy_hosts = collect_host_report_data(app_hosts)
     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 report
+      app_hosts = JSON.parse(@app_instance.hosts)
+      @report_hosts = collect_host_report_data(app_hosts)
 
-    def hardcoded_params
-      result = {}
-      result['managed'] = true
-      result['enabled'] = true
-      result['build'] = true
-      result['compute_attributes'] = { 'start' => '1' }
-      result['host_parameters_attributes'] = []
-      result
+      logger.debug("deploy report hosts are: #{@report_hosts.inspect}")
     end
 
-    def set_host_params
-      result = hardcoded_params
-      result['hostgroup_id'] = @app_instance.app_definition.hostgroup_id
-      JSON.parse(@app_instance.parameters).each do |param|
-        case param['type']
-
-        when 'computeprofile'
-          result['compute_profile_id'] = param['value']
-
-        when 'domain'
-          result['domain_id'] = param['value']
-
-        when 'hostname'
-          result['name'] = 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']
+    private
 
-        when 'password'
-          result['root_pass'] = param['value']
+    def read_applications
+      @applications = AppDefinition.all.map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
+    end
 
-        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
-      result
+      report_data
     end
   end
 end

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, :playfile)
+          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, :hostgroup_id, :parameters)
+            filter.permit(:name, :description, :acd_ansible_playbook_id, :services, :ansible_vars_all)
           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, :parameters)
+            filter.permit(:name, :app_definition_id, :description, :hosts, :ansible_vars_all)
           end
         end
       end

data/app/controllers/foreman_acd/remote_execution_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Class to run remote execution jobs
+  class RemoteExecutionController < JobInvocationsController
+
+    def new
+      jobs = init_configuration
+      @composer = jobs.first
+    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
+        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'
+      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 init_configuration
+      app_instance = ForemanAcd::AppInstance.find_by(:name => params[:id])
+      app_configurator = ForemanAcd::AppConfigurator.new(app_instance)
+
+      jobs = app_configurator.configure
+      logger.debug("Creating #{jobs.count} job(s) to configure the app #{app_instance}. Customize first: #{params[:customize]}")
+      return jobs
+    end
+  end
+end

data/app/controllers/ui_acd_controller.rb

@@ -6,16 +6,19 @@ class UiAcdController < ::Api::V2::BaseController
     @app_data = {}
     app_definition = ForemanAcd::AppDefinition.find(params[:id])
     @app_data['app_definition'] = app_definition
-    @app_data['fdata'] = collect_fdata(app_definition.hostgroup_id)
   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
 
   private
 
-  def collect_fdata(hostgroup_id)
+  def collect_foreman_data(hostgroup_id)
     hg = Hostgroup.find(hostgroup_id)
     fdata = OpenStruct.new(
       :environments => Environment.all,
@@ -27,4 +30,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/models/foreman_acd/ansible_playbook.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  # Ansible playbook
+  class AnsiblePlaybook < ApplicationRecord
+    include Authorizable
+    extend FriendlyId
+    friendly_id :name
+
+    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 -> { order("acd_ansible_playbooks.name") }
+
+    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
+      groups = []
+
+      JSON.load(self.vars).each do |group_name, vars|
+        groups << OpenStruct.new(
+          :name => group_name,
+          :vars => vars.map { |k,v| OpenStruct.new(:name => k, :value => v) })
+      end
+
+      adata = OpenStruct.new(
+        :id => self.id,
+        :name => self.name,
+        :groups => JSON.load(self.vars)
+      )
+      adata
+    end
+  end
+end

data/app/models/foreman_acd/app_definition.rb

@@ -8,9 +8,10 @@ module ForemanAcd
     friendly_id :name
 
     validates :name, :presence => true, :uniqueness => true
-    belongs_to :hostgroup, :class_name => '::Hostgroup'
     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 -> { order("app_definitions.name") }
 
     def self.humanize_class_name(_name = nil)
       _('App Definition')

data/app/models/foreman_acd/app_instance.rb

@@ -9,6 +9,7 @@ module ForemanAcd
     validates :name, :presence => true, :uniqueness => true
     belongs_to :app_definition, :inverse_of => :app_instances
     scoped_search :on => :name
+    default_scope -> { order("app_instances.name") }
 
     def self.humanize_class_name(_name = nil)
       _('App Instance')
@@ -17,5 +18,11 @@ module ForemanAcd
     def self.permission_name
       'app_instances'
     end
+
+    def foreman_hosts
+      app_hosts = JSON.parse(self.hosts)
+      host_ids = app_hosts.select{ |h| h&.key?('foreman_host_id') }.map{ |h| h['foreman_host_id'] }
+      ::Host.find(host_ids)
+    end
   end
 end

data/app/services/foreman_acd/app_configurator.rb

@@ -0,0 +1,70 @@
+# 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_name'] = @app_instance.app_definition.ansible_playbook.name
+      job_input['playbook_path'] = File.join(@app_instance.app_definition.ansible_playbook.path,
+                                            @app_instance.app_definition.ansible_playbook.playfile)
+
+      # TODO should or do we really need it to a file?
+      #inventory_file = File.new("/tmp/acd_inventory_file", "w") # we can also use Tempfile.new() but a tempfile will be deleted soon (after transaction finished)
+      #inventory_file << inventory.to_yaml
+      #inventory_file.close
+
+      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, 'SSH')
+          unless proxy_hosts.has_key?(proxy.name)
+            proxy_hosts[proxy.name] = Array.new
+          end
+          proxy_hosts[proxy.name] << h.id
+        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, host_names|
+          # create the inventory file
+          inventory = ForemanAcd::InventoryCreator.new(@app_instance, host_names).create_inventory
+          job_input['inventory'] = YAML.dump(inventory)
+
+          # Unfortunately, we can not use "JobInvocationComposer.for_feature" method
+          # because then its not possible to the set effective_user
+          job = JobTemplate.find(RemoteExecutionFeature.feature('run_acd_ansible_playbook').job_template_id)
+          params = {
+            :job_category => job.job_category,
+            :job_template_id => job.id,
+            :targeting_type => 'static_query',
+            :search_query => "name = #{proxy_name}",
+            :effective_user => 'foreman-proxy',
+            :inputs => job_input.to_hash
+          }
+          composer = JobInvocationComposer.from_api_params(params)
+          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,139 @@
+# 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
+      services = JSON.parse(@app_instance.app_definition.services)
+      app_hosts = JSON.parse(@app_instance.hosts)
+
+      app_hosts.each do |host_data|
+        begin
+          service_data = services.select { |k| k['id'] == host_data['service'].to_i }.first
+          host_params = set_host_params(host_data, service_data)
+
+          host = nil
+          if host_data.has_key?('foreman_host_id')
+            logger.debug("Try to find host with id #{host_data['foreman_host_id']}")
+            begin
+              host = Host.find(host_data['foreman_host_id'])
+            rescue ActiveRecord::RecordNotFound
+              logger.info("Host with id #{host_data['foreman_host_id']} couldn\'t be found, create a new one!")
+              host = nil
+            end
+          end
+
+          if host.nil?
+            params = host_attributes(host_params)
+            logger.info("Host creation parameters for #{host_data['hostname']}:\n#{params}\n")
+            host = Host.new(params)
+          else
+            logger.info("Update parameters and re-deploy host #{host_data['hostname']}")
+            host.attributes = host_attributes(host_params, host)
+            host.setBuild
+            host.power.reset
+          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
+          host.save
+
+          # save the foreman host id
+          host_data['foreman_host_id'] = host.id
+        rescue StandardError => e
+          logger.error("Failed to initiate host creation: #{e.class}: #{e.message}\n#{e.backtrace.join($INPUT_RECORD_SEPARATOR)}")
+        end
+      end
+
+      return app_hosts
+    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['managed'] = true
+      result['enabled'] = true
+      result['build'] = true
+      result['compute_attributes'] = { 'start' => '1' }
+      result['host_parameters_attributes'] = []
+      result
+    end
+
+    def set_host_params(host_data, service_data)
+      result = hardcoded_params
+      result['name'] = host_data['hostname']
+      result['hostgroup_id'] = service_data['hostgroup']
+
+      host_data['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