katello 3.8.1 → 3.9.0.rc1

data/app/controllers/katello/api/v2/sync_plans_controller.rb

@@ -13,6 +13,7 @@ module Katello
       param :sync_date, String, :desc => N_("start datetime of synchronization"), :required => true, :action_aware => true
       param :description, String, :desc => N_("sync plan description")
       param :enabled, :bool, :desc => N_("enables or disables synchronization"), :required => true, :action_aware => true
+      param :cron_expression, String, :desc => N_("Add custom cron logic for sync plan")
     end
 
     api :GET, "/sync_plans", N_("List sync plans")
@@ -46,17 +47,12 @@ module Katello
     param :organization_id, :number, :desc => N_("Filter sync plans by organization name or label"), :required => true
     param_group :sync_plan
     def create
-      sync_date = sync_plan_params[:sync_date].to_time(:utc)
-
-      unless sync_date.is_a?(Time)
+      unless sync_plan_params[:sync_date].to_time(:utc).is_a?(Time)
         fail _("Date format is incorrect.")
       end
-
       @sync_plan = SyncPlan.new(sync_plan_params)
-      @sync_plan.sync_date = sync_date
       @sync_plan.organization = @organization
-      @sync_plan.save!
-
+      @sync_plan.save_with_logic!
       respond_for_create(:resource => @sync_plan)
     end
 
@@ -67,12 +63,10 @@ module Katello
     param_group :sync_plan
     def update
       sync_date = sync_plan_params.try(:[], :sync_date).try(:to_time)
-
       if !sync_date.nil? && !sync_date.is_a?(Time)
         fail _("Date format is incorrect.")
       end
-
-      sync_task(::Actions::Katello::SyncPlan::Update, @sync_plan, sync_plan_params)
+      @sync_plan.update_attributes_with_logics!(sync_plan_params) if sync_plan_params
       respond_for_show(:resource => @sync_plan)
     end
 
@@ -81,15 +75,16 @@ module Katello
     param :organization_id, :number, :desc => N_("Filter sync plans by organization name or label")
     param :id, :number, :desc => N_("sync plan numeric identifier")
     def destroy
-      sync_task(::Actions::Katello::SyncPlan::Destroy, @sync_plan)
-      respond_for_show(:resource => @sync_plan)
+      @sync_plan.destroy!
     end
 
     api :PUT, "/organizations/:organization_id/sync_plans/:id/add_products", N_("Add products to sync plan")
     param :id, String, :desc => N_("ID of the sync plan"), :required => true
     param :product_ids, Array, :desc => N_("List of product ids to add to the sync plan"), :required => true
     def add_products
-      sync_task(::Actions::Katello::SyncPlan::AddProducts, @sync_plan, params[:product_ids])
+      products = ::Katello::Product.where(:id => params[:product_ids]).editable
+      @sync_plan.product_ids = (@sync_plan.product_ids + products.collect { |p| p.id }).uniq
+      @sync_plan.save!
       respond_for_show
     end
 
@@ -97,7 +92,9 @@ module Katello
     param :id, String, :desc => N_("ID of the sync plan"), :required => true
     param :product_ids, Array, :desc => N_("List of product ids to remove from the sync plan"), :required => true
     def remove_products
-      sync_task(::Actions::Katello::SyncPlan::RemoveProducts, @sync_plan, params[:product_ids])
+      products = ::Katello::Product.where(:id => params[:product_ids]).editable
+      @sync_plan.product_ids = (@sync_plan.product_ids - products.collect { |p| p.id }).uniq
+      @sync_plan.save!
       respond_for_show
     end
 
@@ -105,16 +102,8 @@ module Katello
     api :PUT, "/organizations/:organization_id/sync_plans/:id/sync", N_("Initiate a sync of the products attached to the sync plan")
     param :id, String, :desc => N_("ID of the sync plan"), :required => true
     def sync
-      syncable_products = @sync_plan.products.syncable
-      syncable_repositories = Repository.where(:product_id => syncable_products).has_url
-
-      task = async_task(::Actions::BulkAction,
-                        ::Actions::Katello::Repository::Sync,
-                        syncable_repositories)
-
+      task = async_task(::Actions::Katello::SyncPlan::Run, @sync_plan)
       respond_for_async :resource => task
-    rescue Foreman::Exception
-      raise HttpErrors::BadRequest, _("No products within sync plan")
     end
 
     protected
@@ -127,7 +116,7 @@ module Katello
     end
 
     def sync_plan_params
-      params.require(:sync_plan).permit(:name, :description, :interval, :sync_date, :product_ids, :enabled)
+      params.require(:sync_plan).permit(:name, :description, :interval, :sync_date, :product_ids, :enabled, :cron_expression)
     end
   end
 end

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -52,12 +52,17 @@ module Katello
           fail HttpErrors::NotFound, _("Couldn't find content view versions '%s'") % missing.join(',')
         end
 
-        collection = resource_class.all
-        repos = Katello::Repository.where(:content_view_version_id => @versions.pluck(:id))
-        repos = repos.where(:library_instance_id => @repo.id) if @repo
-
         sort_by, sort_order, options = sort_options
-        collection = scoped_search(filter_by_repos(repos, collection).distinct, sort_by, sort_order, options)
+
+        if respond_to?(:custom_collection_by_content_view_version)
+          collection = custom_collection_by_content_view_version(@versions)
+        else
+          repos = Katello::Repository.where(:content_view_version_id => @versions.pluck(:id))
+          repos = repos.where(:library_instance_id => @repo.id) if @repo
+          collection = filter_by_repos(repos, resource_class.all)
+        end
+
+        collection = scoped_search(collection.distinct, sort_by, sort_order, options)
         collection[:results] = collection[:results].map { |item| ContentViewVersionComparePresenter.new(item, @versions, @repo) }
         respond_for_index(:collection => collection)
       end
@@ -220,6 +225,8 @@ module Katello
           _("OSTree Branch")
         when "Katello::FileUnit"
           _("File")
+        when "Katello::ModuleStream"
+          _("Module Stream")
         else
           fail "Can't find resource class: #{resource_class}"
         end

data/app/controllers/katello/concerns/hosts_controller_extensions.rb

@@ -19,11 +19,8 @@ module Katello
         prepend Overrides
 
         def destroy
-          if Katello::RegistrationManager.unregister_host(@host, :unregistering => false)
-            process_success(:success_redirect => hosts_path)
-          else
-            process_error :redirect => :back, :error_msg => _("Failed to delete %{host}: %{errors}") % { :host => @host, :errors => @host.errors.full_messages }
-          end
+          Katello::RegistrationManager.unregister_host(@host, :unregistering => false)
+          process_success :success_redirect => hosts_path
         rescue StandardError => ex
           process_error(:object => @host, :error_msg => ex.message, :redirect => saved_redirect_url_or(send("#{controller_name}_url")))
         end

data/app/controllers/katello/react_controller.rb

@@ -2,6 +2,8 @@ module Katello
   class ReactController < ::ApplicationController
     skip_before_action :authorize
 
+    include Rails.application.routes.url_helpers
+
     def index
       render 'katello/layouts/react', :layout => false
     end

data/app/controllers/katello/remote_execution_controller.rb

@@ -1,6 +1,8 @@
 module Katello
   if Katello.with_remote_execution?
     class RemoteExecutionController < JobInvocationsController
+      include Concerns::Api::V2::BulkHostsExtensions
+
       def new
         @composer = prepare_composer
       end
@@ -28,11 +30,14 @@ module Katello
       end
 
       def hosts
-        if params[:scoped_search].present?
-          params[:scoped_search]
-        else
-          ::Host.where(:id => params[:host_ids].try(:split, ','))
-        end
+        host_ids = params[:host_ids].is_a?(String) ? params[:host_ids].split(',') : params[:host_ids]
+        find_bulk_hosts('edit_hosts',
+          included: {
+            ids: host_ids,
+            search: params[:scoped_search],
+            excluded: params[:excluded]
+          }
+                       )
       end
 
       def inputs
@@ -40,6 +45,12 @@ module Katello
           { :errata => params[:name] }
         elsif feature_name == 'katello_service_restart'
           { :helper => params[:name] }
+        elsif feature_name == 'katello_module_stream_action'
+          fail HttpErrors::NotFound, _('module streams not found') if params[:module_spec].blank?
+          fail HttpErrors::NotFound, _('actions not found') if params[:module_stream_action].blank?
+          inputs = { :module_spec => params[:module_spec], :action => params[:module_stream_action] }
+          inputs[:options] = params[:options] if params[:options]
+          inputs
         else
           { :package => params[:name] }
         end

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -34,8 +34,6 @@ module Katello
     end
 
     def kickstart_repository_id(host, options = {})
-      return if host.try(:medium_id).present?
-
       host_ks_repo_id = host_hostgroup_kickstart_repository_id(host)
       ks_repo_options = kickstart_repository_options(host, options)
       # if the kickstart repo id is set in the selected_hostgroup use that

data/app/lib/actions/candlepin/import_pool_handler.rb

@@ -1,6 +1,8 @@
 module Actions
   module Candlepin
     class ImportPoolHandler
+      attr_reader :message_handler
+
       def initialize(logger)
         @logger = logger
       end
@@ -11,7 +13,7 @@ module Actions
 
         ::User.current = ::User.anonymous_admin
 
-        message_handler = ::Katello::Candlepin::MessageHandler.new(message)
+        @message_handler = ::Katello::Candlepin::MessageHandler.new(message)
 
         case message_handler.subject
         when /entitlement\.created/
@@ -24,26 +26,49 @@ module Actions
           message_handler.import_pool
         when /pool\.deleted/
           message_handler.import_pool
-        when /compliance\.created/
-          reindex_consumer(message_handler)
+        when /^compliance\.created/
+          reindex_subscription_status
+        when /system_purpose_compliance\.created/
+          reindex_purpose_status
         end
       end
 
       private
 
-      def reindex_consumer(message_handler)
-        subscription_facet = message_handler.subscription_facet
-        sub_status = message_handler.sub_status
-        uuid = message_handler.consumer_uuid
-        if subscription_facet && sub_status
-          @logger.debug "re-indexing content host #{subscription_facet.host.name}"
-          subscription_facet.update_subscription_status(sub_status)
-          subscription_facet.update_compliance_reasons(message_handler.consumer_reasons)
-        elsif subscription_facet.nil?
-          @logger.debug "skip re-indexing of non-existent content host #{uuid}"
-        elsif sub_status.nil?
-          @logger.debug "skip re-indexing of empty subscription status #{uuid}"
+      def subscription_facet
+        message_handler.subscription_facet
+      end
+
+      def reindex_subscription_status
+        if message_handler.status.nil?
+          @logger.debug "skip re-indexing of empty #{message_handler.subject} status #{message_handler.consumer_uuid}"
+          return
         end
+
+        reindex_consumer do
+          subscription_facet.update_subscription_status(message_handler.status)
+          subscription_facet.update_compliance_reasons(message_handler.reasons)
+        end
+      end
+
+      def reindex_purpose_status
+        reindex_consumer do
+          subscription_facet.update_purpose_status(valid_role: message_handler.compliant_role?,
+                                                   valid_usage: message_handler.compliant_usage?,
+                                                   valid_addons: message_handler.compliant_addons?,
+                                                   valid_sla: message_handler.compliant_sla?)
+        end
+      end
+
+      def reindex_consumer
+        if subscription_facet.nil?
+          @logger.debug "skip re-indexing of non-existent content host #{message_handler.consumer_uuid}"
+          return
+        end
+
+        @logger.debug "re-indexing content host #{subscription_facet.host.name}"
+
+        yield
       end
     end
   end

data/app/lib/actions/katello/capsule_content/create_repos.rb

@@ -44,6 +44,7 @@ module Actions
                       path: relative_path,
                       with_importer: true,
                       docker_upstream_name: repository.docker? ? repository.container_repository_name : nil,
+                      docker_tags_whitelist: repository.docker? ? repository.docker_tags_whitelist : nil,
                       repo_registry_id: repository.docker? ? repository.container_repository_name : nil,
                       download_policy: repository.capsule_download_policy(capsule_content.capsule),
                       capsule_id: capsule_content.capsule.id)

data/app/lib/actions/katello/content_view/publish.rb

@@ -9,7 +9,26 @@ module Actions
         def plan(content_view, description = "", options = {})
           action_subject(content_view)
           content_view.check_ready_to_publish!
-          version = content_view.create_new_version
+
+          if options[:repos_units].present?
+            valid_labels_from_cv = content_view.repositories.map(&:label)
+            labels_from_repos_units = options[:repos_units].map { |repo| repo[:label] }
+
+            labels_from_repos_units.each do |label|
+              fail _("Repository label '%s' is not associated with content view.") % label unless valid_labels_from_cv.include? label
+            end
+
+            valid_labels_from_cv.each do |label|
+              fail _("Content view has repository label '%s' which is not specified in repos_units parameter.") % label unless labels_from_repos_units.include? label
+            end
+          end
+
+          if options[:minor] && options[:major]
+            version = content_view.create_new_version(options[:major], options[:minor])
+          else
+            version = content_view.create_new_version
+          end
+
           library = content_view.organization.library
           history = ::Katello::ContentViewHistory.create!(:content_view_version => version,
                                                           :user => ::User.current.login,
@@ -25,7 +44,7 @@ module Actions
             concurrence do
               content_view.publish_repositories do |repositories|
                 sequence do
-                  clone_to_version = plan_action(Repository::CloneToVersion, repositories, version)
+                  clone_to_version = plan_action(Repository::CloneToVersion, repositories, version, :repos_units => options[:repos_units])
                   plan_action(Repository::CloneToEnvironment, clone_to_version.new_repository, library,
                               :force_yum_metadata_regeneration => options[:force_yum_metadata_regeneration])
                 end

data/app/lib/actions/katello/content_view_version/incremental_update.rb

@@ -66,7 +66,7 @@ module Actions
         def copy_repos(source_repos, new_version, content, dep_solve)
           copy_output = []
           sequence do
-            new_repo = plan_action(Repository::CloneToVersion, source_repos, new_version, true).new_repository
+            new_repo = plan_action(Repository::CloneToVersion, source_repos, new_version, :incremental => true).new_repository
             copy_output = copy_yum_content(new_repo, dep_solve, content[:package_ids], content[:errata_ids])
 
             plan_action(Katello::Repository::MetadataGenerate, new_repo)

data/app/lib/actions/katello/environment/destroy.rb

@@ -10,9 +10,8 @@ module Actions
         end
 
         def plan(env, options = {})
-          unless env.deletable?
-            fail env.errors.full_messages.join(" ")
-          end
+          fail env.errors.full_messages.join(" ") unless env.deletable?
+
           skip_repo_destroy = options.fetch(:skip_repo_destroy, false)
           organization_destroy = options.fetch(:organization_destroy, false)
           sequence do

data/app/lib/actions/katello/environment/publish_repositories.rb

@@ -10,7 +10,7 @@ module Actions
         end
 
         def plan(env, options = {})
-          repositories = options[:content_type] ? env.repositories.where(content_type: options[:content_type]) : env.repositories
+          repositories = options[:content_type] ? env.repositories.with_type(options[:content_type]) : env.repositories
           action_subject(env)
           concurrence do
             repositories.each do |repository|

data/app/lib/actions/katello/event_queue/monitor.rb

@@ -4,8 +4,8 @@ module Actions
       class Monitor < Actions::Base
         include ::Dynflow::Action::Singleton
 
-        Event = Algebrick.type do
-          fields! event_type: String, object_id: Integer, created_at: Time
+        Count = Algebrick.type do
+          fields! count: Integer, time: Time
         end
 
         Fatal = Algebrick.type do
@@ -33,6 +33,7 @@ module Actions
         end
 
         def run(event = nil)
+          action_logger.debug("message_queue_event: #{event}")
           match(event,
                 (on nil do
                   initialize_service
@@ -40,8 +41,8 @@ module Actions
                 (on Ready do
                   listen_for_events
                 end),
-                (on Event do
-                   act_on_event(event)
+                (on Count do
+                   update_count(event)
                  end),
                 (on Close | Dynflow::Action::Cancellable::Cancel do
                    close_service
@@ -105,17 +106,10 @@ module Actions
           end
         end
 
-        def act_on_event(event)
-          ::User.as_anonymous_admin do
-            output[:last_event] = "#{event.event_type} - #{event.object_id}"
-            ::Katello::EventQueue.event_class(event.event_type).new(event.object_id).run
-          end
-        rescue => e
-          world.logger.error(e.message)
-          world.logger.error(e.backtrace.join("\n"))
-          output[:last_error] = e.message
-        ensure
-          ::Katello::EventQueue.clear_events(event.event_type, event.object_id, event.created_at)
+        def update_count(event)
+          output[:count] ||= 0
+          output[:count] += event.count
+          output[:last_count_update] = event.time
           suspend
         end
 

data/app/lib/actions/katello/event_queue/poller_thread.rb

@@ -3,6 +3,7 @@ module Actions
     module EventQueue
       class PollerThread
         SLEEP_INTERVAL = 2
+        COUNT_UPDATE_INTERVAL = 250
         cattr_accessor :instance
 
         def self.initialize(logger)
@@ -22,16 +23,38 @@ module Actions
           @thread.kill if @thread
         end
 
+        def run_event(event)
+          @logger.debug("event_queue_event: #{event.event_type}, #{event.object_id}")
+          ::User.as_anonymous_admin do
+            ::Katello::EventQueue.event_class(event.event_type).new(event.object_id).run
+          end
+        rescue => e
+          @logger.error("event_queue_error: #{event.event_type}, #{event.object_id}")
+          @logger.error(e.message)
+          @logger.error(e.backtrace.join("\n"))
+        ensure
+          ::Katello::EventQueue.clear_events(event.event_type, event.object_id, event.created_at)
+        end
+
         def poll_for_events(suspended_action)
           @thread.kill if @thread
           @thread = Thread.new do
             loop do
               Rails.application.executor.wrap do
                 begin
+                  count = 0
+
                   until (event = ::Katello::EventQueue.next_event).nil?
-                    suspended_action.notify_queue_item(event.event_type, event.object_id, event.created_at) if event
+                    run_event(event)
+                    count += 1
+
+                    if count > COUNT_UPDATE_INTERVAL
+                      suspended_action.notify_count(count)
+                      count = 0
+                    end
                   end
 
+                  suspended_action.notify_count(count) if count > 0
                   sleep SLEEP_INTERVAL
                 rescue => e
                   suspended_action.notify_fatal(e)