foreman_acd 0.2.1 → 0.7.0

data/app/controllers/foreman_acd/api/v2/app_definitions_controller.rb

@@ -23,6 +23,7 @@ module ForemanAcd
         def_param_group :app_definition do
           param :app_definition, Hash, :required => true, :action_aware => true do
             param :name, String, :required => true
+            param_group :taxonomies, ::Api::V2::BaseController
             param :description, String, :required => true
             param :services, String, :required => true
           end

data/app/controllers/foreman_acd/api/v2/app_instances_controller.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ForemanAcd
+  module Api
+    module V2
+      # API controller for App Instances
+      class AppInstancesController < ::ForemanAcd::Api::V2::BaseController
+        include ::ForemanAcd::Concerns::AppInstanceParameters
+
+        before_action :find_resource, :except => [:index, :create]
+
+        api :GET, '/app_instances/:id', N_('Show application instance')
+        param :id, :identifier, :required => true
+        param :organization_id, :identifier, :required => true
+        param :location_id, :identifier, :required => true
+        def show; end
+
+        api :GET, '/app_instances', N_('List application instances')
+        param :organization_id, :identifier, :required => true
+        param :location_id, :identifier, :required => true
+        param_group :search_and_pagination, ::Api::V2::BaseController
+        add_scoped_search_description_for(AppInstance)
+        def index
+          scope = resource_scope_for_index.where(:organization => params[:organization_id]) if params[:organization_id].present?
+          scope = scope.where(:location => params[:location_id]) if params[:location_id].present?
+          @app_instances = scope
+        end
+
+        def_param_group :app_instance do
+          param :app_instance, Hash, :required => true, :action_aware => true do
+            param :name, String, :required => true
+            param :organization_id, :identifier, :required => true
+            param :location_id, :identifier, :required => true
+            param :description, String, :required => true
+            param :services, String, :required => true
+          end
+        end
+
+        api :POST, '/app_instances', N_('Create a application instance')
+        param_group :app_instance, :as => :create
+        def create
+          @app_instance = AppInstance.new(app_instance_params)
+          process_response @app_instance.save
+        end
+
+        api :DELETE, '/app_instances/:id', N_('Deletes application instance')
+        param :id, :identifier, :required => true
+        def destroy
+          process_response @app_instance.destroy
+        end
+
+        def controller_permission
+          'app_instances'
+        end
+
+        def resource_class
+          ForemanAcd::AppInstance
+        end
+      end
+    end
+  end
+end

data/app/controllers/foreman_acd/app_definitions_controller.rb

@@ -7,33 +7,41 @@ module ForemanAcd
     include ::ForemanAcd::Concerns::AppDefinitionParameters
 
     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]
 
     def index
       @app_definitions = resource_base.search_for(params[:search], :order => params[:order]).paginate(:page => params[:page])
     end
 
+    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 }
+    end
+
     def read_hostgroups
       @hostgroups = Hostgroup.all.map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
     end
 
     def new
-      read_hostgroups
       @app_definition = AppDefinition.new
     end
 
     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
+        redirect_to new_app_definition_path, :flash => { :error => _(e.message) }
       end
     end
 
-    def edit
-      read_hostgroups
-    end
+    def edit; end
 
     def update
       if @app_definition.update(app_definition_params)
@@ -55,13 +63,14 @@ module ForemanAcd
       case params[:action]
       when 'export'
         :export
+      when 'import'
+        :import
       else
         super
       end
     end
 
     def import
-      read_hostgroups
       @app_definition = AppDefinition.new
     end
 
@@ -74,7 +83,7 @@ module ForemanAcd
     private
 
     def handle_file_upload
-      return unless params[:foreman_acd_app_definition] && raw_file = params[:foreman_acd_app_definition][:app_definition_file]
+      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
     end
   end

data/app/controllers/foreman_acd/app_instances_controller.rb

@@ -6,45 +6,53 @@ module ForemanAcd
     include Foreman::Controller::AutoCompleteSearch
     include ::ForemanAcd::Concerns::AppInstanceParameters
 
-    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])
-    end
-
-    def read_applications
-      @applications = ForemanAcd::AppDefinition.all.map { |elem| { elem.id => elem.name } }.reduce({}) { |h, v| h.merge v }
+      @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
-      read_applications
+      @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
-      read_applications
-    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
@@ -56,152 +64,118 @@ module ForemanAcd
         :deploy
       when 'report'
         :report
+      when 'destroy_with_hosts'
+        :destroy
       else
         super
       end
     end
 
     def deploy
-      services = JSON.parse(@app_instance.app_definition.services)
-      @deploy_hosts = []
-
-      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?
-            logger.info("Host creation parameters for #{host_data['hostname']}:\n#{params}\n")
-            params = host_attributes(host_params)
-            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
-
-          @deploy_hosts.push({ id: host.id, name: host_data['hostname'], hostname: host.hostname, hostUrl: host_path(h), progress_report_id: host.progress_report_id})
-        rescue StandardError => e
-          logger.error("Failed to initiate host creation: #{e.backtrace.join($INPUT_RECORD_SEPARATOR)}")
-        end
-      end
-
-      # save any change to the app_hosts json
-      @app_instance.hosts = app_hosts.to_json
-      @app_instance.save
+      value = false
+      @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)
+      process_success(:success_msg => _('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
 
-    def report
-      @report_hosts = []
-      app_hosts = JSON.parse(@app_instance.hosts)
-      app_hosts.each do |host_data|
-        h = Host.find(host_data['foreman_host_id'])
-        @report_hosts.push({id: h.id, name: host_data['hostname'], hostname: h.hostname, hostUrl: host_path(h), powerStatusUrl: power_api_host_path(h) })
-      end
-
-      logger.debug("deploy report hosts are: #{@report_hosts.inspect}")
+    def safe_deploy?
+      return false if session[:remember_hosts].empty?
+      session[:remember_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)
+    def report
+      @report_hosts = collect_host_report_data
+      logger.debug("app instance host details: #{@report_hosts.inspect}")
     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?)
+    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'],
+                                             :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
-      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
+      # 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 hardcoded_params
-      result = {}
-      result['managed'] = true
-      result['enabled'] = true
-      result['build'] = true
-      result['compute_attributes'] = { 'start' => '1' }
-      result['host_parameters_attributes'] = []
-      result
+    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,
+          :foremanParameters => JSON.parse(h.foremanParameters),
+          :ansibleParameters => JSON.parse(h.ansibleParameters)
+        }
+      end
+      hosts_data
     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['parameters'].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'] }
+    private
 
-        when 'ptable'
-          result['ptable_id'] = param['value']
+    def find_taxonomy
+      @organization = Organization.current
+      redirect_to '/select_organization?toState=' + request.path and return unless @organization
 
-        when 'puppetenv'
-          result['environment_id'] = param['value']
+      @location = Location.current
+      redirect_to root_path, :error => 'Select a location to show App Instances' and return unless @location
+    end
 
-        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
 
+    def collect_host_report_data
+      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),
+                          :powerStatusUrl => power_api_host_path(foreman_host.host)
+                        })
         end
+        report_data << a_host
       end
-      result
+      report_data
     end
   end
 end