katello 3.6.0.1.rc2 → 3.7.0.rc1

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

@@ -205,9 +205,9 @@ module Katello
         when "Katello::PuppetModule"
           _("Puppet Module")
         when "Katello::DockerManifest"
-          _("Docker Manifest")
+          _("Container Image Manifest")
         when "Katello::DockerMetaTag"
-          _("Docker Tag")
+          _("Container Image Tag")
         when "Katello::OstreeBranch"
           _("OSTree Branch")
         when "Katello::FileUnit"

data/app/helpers/katello/katello_urls_helper.rb

@@ -1,19 +1,36 @@
 require 'uri'
+
 module Katello
   module KatelloUrlsHelper
-    def host(url)
-      URI(url).host unless url.nil?
+    def foreman_settings_url(schema = 'http')
+      ::Setting[:foreman_url].sub(%r|^.*?:|, "#{schema}:")
     end
 
     def subscription_manager_configuration_url(host = nil, rpm = true)
       prefix = if host && host.content_source
-                 "http://#{@host.content_source.hostname}"
+                 "http://#{host.content_source.hostname}"
                else
-                 Setting[:foreman_url].sub(/\Ahttps/, 'http')
+                 foreman_settings_url
                end
       config = rpm ? SETTINGS[:katello][:consumer_cert_rpm] : SETTINGS[:katello][:consumer_cert_sh]
 
       "#{prefix}/pub/#{config}"
     end
+
+    def repository_url(content_path, content_type = 'repos', schema = 'http')
+      return content_path if content_path =~ %r|^([\w\-\+]+)://|
+      url = if @host.content_source
+              "#{schema}://#{@host.content_source.hostname}"
+            else
+              foreman_settings_url(schema)
+            end
+      content_path = content_path.sub(%r|^/|, '')
+      if @host.content_view && !@host.content_view.default?
+        content_path = [@host.content_view.label, content_path].join('/')
+      end
+      path = ::Katello::Glue::Pulp::Repos.repo_path_from_content_path(
+        @host.lifecycle_environment, content_path)
+      "#{url}/pulp/#{content_type}/#{path}"
+    end
   end
 end

data/app/jobs/create_pulp_disk_space_notifications.rb

@@ -6,4 +6,8 @@ class CreatePulpDiskSpaceNotifications < ApplicationJob
   def perform
     Katello::UINotifications::Pulp::ProxyDiskSpace.deliver!
   end
+
+  def humanized_name
+    _('Pulp disk space notification')
+  end
 end

data/app/jobs/send_expire_soon_notifications.rb

@@ -0,0 +1,13 @@
+class SendExpireSoonNotifications < ApplicationJob
+  after_perform do
+    self.class.set(:wait => 12.hours).perform_later
+  end
+
+  def perform
+    Katello::UINotifications::Subscriptions::ExpireSoon.deliver!
+  end
+
+  def humanized_name
+    _('Subscription expiration notification')
+  end
+end

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

@@ -15,15 +15,15 @@ module Actions
 
         case message_handler.subject
         when /entitlement\.created/
-          message_handler.import_pool_by_reference_id
+          message_handler.import_pool
           message_handler.create_pool_on_host
         when /entitlement\.deleted/
-          message_handler.import_pool_by_reference_id
+          message_handler.import_pool
           message_handler.remove_pool_from_host
         when /pool\.created/
-          message_handler.import_pool_by_entity_id
+          message_handler.import_pool
         when /pool\.deleted/
-          message_handler.import_pool_by_entity_id
+          message_handler.import_pool
         when /compliance\.created/
           reindex_consumer(message_handler)
         end
@@ -38,6 +38,7 @@ module Actions
         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?

data/app/lib/actions/candlepin/owner/import_products.rb

@@ -8,8 +8,10 @@ module Actions
 
         def run
           organization = ::Organization.find(input[:organization_id])
-          User.as_anonymous_admin do
-            organization.redhat_provider.import_products_from_cp
+          ::Katello::Product.without_auditing do
+            User.as_anonymous_admin do
+              organization.redhat_provider.import_products_from_cp
+            end
           end
         end
       end

data/app/lib/actions/helpers/notifications.rb

@@ -0,0 +1,35 @@
+module Actions
+  module Helpers
+    module Notifications
+      def self.included(base)
+        base.execution_plan_hooks.use :send_notification, :on => [:stopped]
+      end
+
+      def send_notification(plan)
+        if plan_failed?(plan)
+          failure_notification(plan)
+        else
+          success_notification(plan)
+        end
+      end
+
+      def success_notification(plan)
+      end
+
+      def failure_notification(plan)
+      end
+
+      def plan_failed?(plan)
+        [:error, :warning, :cancelled].include?(plan.result)
+      end
+
+      def subject_organization
+        @organization ||= ::Organization.find(input[:organization][:id])
+      end
+
+      def get_foreman_task(plan)
+        ::ForemanTasks::Task::DynflowTask.where(:external_id => plan.id).first
+      end
+    end
+  end
+end

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

@@ -38,13 +38,24 @@ module Actions
           affected_repos = affected_repositories(capsule_content, environment, content_view, repository)
           need_updates = repos_needing_updates(capsule_content, affected_repos)
           repository_ids = get_repository_ids(capsule_content, environment, content_view, repository)
+
+          # Create a list of non-puppet repos to sync first, and then sync puppet repos last.
+          # Puppet modules may refer to non-puppet content in the same CV, and thus need to publish last.
+          puppet_repository_ids = []
+          non_puppet_repository_ids = []
+          repository_ids.each do |repo_id|
+            repo = ::Katello::Repository.find_by(pulp_id: repo_id) || ::Katello::ContentViewPuppetEnvironment.find_by(pulp_id: repo_id)
+            repo.content_type == 'puppet' ? puppet_repository_ids << repo_id : non_puppet_repository_ids << repo_id
+          end
+
           unless repository_ids.blank?
             sequence do
               need_updates.each do |repo|
                 plan_action(Pulp::Repository::Refresh, repo, capsule_id: capsule_content.capsule.id)
               end
               plan_action(ConfigureCapsule, capsule_content, environment, content_view, repository)
-              sync_repos_to_capsule(capsule_content, repository_ids, skip_metadata_check)
+              sync_repos_to_capsule(capsule_content, non_puppet_repository_ids, skip_metadata_check) unless non_puppet_repository_ids.blank?
+              sync_repos_to_capsule(capsule_content, puppet_repository_ids, skip_metadata_check) unless puppet_repository_ids.blank?
             end
           end
         end

data/app/lib/actions/katello/content_view/{capsule_generate_and_sync.rb → capsule_sync.rb}

@@ -1,7 +1,7 @@
 module Actions
   module Katello
     module ContentView
-      class CapsuleGenerateAndSync < Actions::Base
+      class CapsuleSync < Actions::Base
         def humanized_name
           _("Sync Content View on Smart Proxy(ies)")
         end

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

@@ -45,7 +45,7 @@ module Actions
         def run
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           if ::Katello::CapsuleContent.sync_needed?(environment)
-            ForemanTasks.async_task(ContentView::CapsuleGenerateAndSync,
+            ForemanTasks.async_task(ContentView::CapsuleSync,
                                     ::Katello::ContentView.find(input[:content_view_id]),
                                     environment)
           end

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

@@ -11,13 +11,13 @@ module Actions
           content_view.check_ready_to_publish!
           version = content_view.create_new_version
           library = content_view.organization.library
-
           history = ::Katello::ContentViewHistory.create!(:content_view_version => version,
                                                           :user => ::User.current.login,
                                                           :status => ::Katello::ContentViewHistory::IN_PROGRESS,
                                                           :action => ::Katello::ContentViewHistory.actions[:publish],
                                                           :task => self.task,
-                                                          :notes => description
+                                                          :notes => description,
+                                                          :triggered_by => options[:triggered_by]
                                                          )
 
           sequence do
@@ -31,22 +31,20 @@ module Actions
                 end
               end
 
-              sequence do
-                has_modules = content_view.publish_puppet_environment?
-                plan_action(ContentViewPuppetEnvironment::CreateForVersion, version)
-                plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
-                            :puppet_modules_present => has_modules)
-              end
-
               repos_to_delete(content_view).each do |repo|
                 plan_action(Repository::Destroy, repo, :skip_environment_update => true, :planned_destroy => true)
               end
             end
+            has_modules = content_view.publish_puppet_environment?
+            plan_action(ContentViewPuppetEnvironment::CreateForVersion, version)
+            plan_action(ContentViewPuppetEnvironment::Clone, version, :environment => library,
+                :puppet_modules_present => has_modules)
 
             plan_action(ContentView::UpdateEnvironment, content_view, library)
             plan_action(Katello::Foreman::ContentUpdate, library, content_view)
             plan_action(ContentView::ErrataMail, content_view, library)
             plan_self(history_id: history.id, content_view_id: content_view.id,
+                      content_view_version_id: version.id,
                       environment_id: library.id, user_id: ::User.current.id)
           end
         end
@@ -57,9 +55,40 @@ module Actions
 
         def run
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
+          view = ::Katello::ContentView.find(input[:content_view_id])
+          version = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          output[:content_view_id] = view.id
+          output[:content_view_version_id] = version.id
+          unless view.composite?
+            output[:composite_version_auto_published] = []
+            output[:composite_view_publish_failed] = []
+            output[:composite_auto_publish_task_id] = []
+
+            # Iterate through the list of composites
+            # this component belongs to
+            view.component_composites.each do |cv_component|
+              if cv_component.latest? && cv_component.composite_content_view.auto_publish?
+                description = _("Auto Publish - Triggered by '%{component}'") %
+                                { :component => version.name }
+                begin
+                  task = ForemanTasks.async_task(::Actions::Katello::ContentView::Publish,
+                                          cv_component.composite_content_view,
+                                          description,
+                                          :triggered_by => version)
+                  output[:composite_auto_publish_task_id] << task.id
+                  output[:composite_version_auto_published] << task.input[:content_view_version_id]
+                rescue StandardError
+                  ::Katello::UINotifications::ContentView::AutoPublishFailure.deliver!(
+                                              cv_component.composite_content_view)
+                  output[:composite_view_publish_failed] << cv_component.composite_content_view.id
+                end
+              end
+            end
+          end
+
           if ::Katello::CapsuleContent.sync_needed?(environment)
-            ForemanTasks.async_task(ContentView::CapsuleGenerateAndSync,
-                                    ::Katello::ContentView.find(input[:content_view_id]),
+            ForemanTasks.async_task(ContentView::CapsuleSync,
+                                    view,
                                     environment)
           end
         rescue ::Katello::Errors::CapsuleCannotBeReached # skip any capsules that cannot be connected to

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

@@ -66,8 +66,8 @@ module Actions
                       content_view_history_ids: cv_histories.map { |history| history.id })
 
             if organization_destroy
-              content_view.hostgroups.clear
-              content_view.hosts.clear
+              content_view.hostgroups.destroy_all
+              content_view.hosts.destroy_all
             end
           end
         end

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

@@ -0,0 +1,41 @@
+module Actions
+  module Katello
+    module Environment
+      class PublishRepositories < Actions::EntryAction
+        middleware.use ::Actions::Middleware::RemoteAction
+
+        input_format do
+          param :id
+          param :name
+        end
+
+        def plan(env, options = {})
+          repositories = options[:content_type] ? env.repositories.where(content_type: options[:content_type]) : env.repositories
+          action_subject(env)
+          concurrence do
+            repositories.each do |repository|
+              sequence do
+                plan_action(::Actions::Katello::Repository::Update, repository, container_repository_name: repository.container_repository_name)
+                plan_action(::Actions::Katello::Repository::CapsuleSync, repository)
+              end
+            end
+
+            plan_self
+          end
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
+        def humanized_name
+          _("Publish Lifecycle Environment Repositories")
+        end
+
+        def humanized_input
+          input['kt_environment'].nil? ? super : ["'#{input['kt_environment']['name']}'"] + super
+        end
+      end
+    end
+  end
+end

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

@@ -26,15 +26,17 @@ module Actions
           @thread.kill if @thread
           @thread = Thread.new do
             loop do
-              begin
-                until (event = ::Katello::EventQueue.next_event).nil?
-                  suspended_action.notify_queue_item(event.event_type, event.object_id, event.created_at) if event
-                end
+              Rails.application.executor.wrap do
+                begin
+                  until (event = ::Katello::EventQueue.next_event).nil?
+                    suspended_action.notify_queue_item(event.event_type, event.object_id, event.created_at) if event
+                  end
 
-                sleep SLEEP_INTERVAL
-              rescue => e
-                suspended_action.notify_fatal(e)
-                raise e
+                  sleep SLEEP_INTERVAL
+                rescue => e
+                  suspended_action.notify_fatal(e)
+                  raise e
+                end
               end
             end
           end

data/app/lib/actions/katello/host/attach_subscriptions.rb

@@ -29,7 +29,7 @@ module Actions
         def finalize
           ::Katello::Pool.where(:id => input[:pool_ids]).map { |pool| pool.import_data(false) }
           host = ::Host.find_by(:id => input[:host_id])
-          host.subscription_facet.update_subscription_status
+          host.subscription_facet.import_database_attributes
         end
 
         def rescue_strategy

data/app/lib/actions/katello/host/remove_subscriptions.rb

@@ -28,7 +28,7 @@ module Actions
         def finalize
           ::Katello::Pool.where(:cp_id => input[:pool_ids]).map { |pool| pool.import_data(false) }
           host = ::Host.find_by(:id => input[:host_id])
-          host.subscription_facet.update_subscription_status
+          host.subscription_facet.import_database_attributes
         end
 
         def rescue_strategy

data/app/lib/actions/katello/organization/manifest_delete.rb

@@ -4,6 +4,8 @@ module Actions
       class ManifestDelete < Actions::AbstractAsyncTask
         middleware.use Actions::Middleware::PropagateCandlepinErrors
 
+        include Helpers::Notifications
+
         def plan(organization)
           action_subject(organization)
 
@@ -15,12 +17,32 @@ module Actions
                 plan_action(Katello::Repository::RefreshRepository, repo)
               end
             end
+            plan_self
           end
         end
 
+        def failure_notification(plan)
+          ::Katello::UINotifications::Subscriptions::ManifestDeleteError.deliver!(
+            :subject => subject_organization,
+            :task => get_foreman_task(plan)
+          )
+        end
+
+        def success_notification(_plan)
+          ::Katello::UINotifications::Subscriptions::ManifestDeleteSuccess.deliver!(
+            subject_organization
+          )
+        end
+
         def humanized_name
           _("Delete Manifest")
         end
+
+        def finalize
+          subject_organization.update_attributes!(
+            :manifest_refreshed_at => Time.now,
+            :audit_comment => _('Manifest deleted'))
+        end
       end
     end
   end

data/app/lib/actions/katello/organization/manifest_import.rb

@@ -4,6 +4,8 @@ module Actions
       class ManifestImport < Actions::AbstractAsyncTask
         middleware.use Actions::Middleware::PropagateCandlepinErrors
 
+        include Helpers::Notifications
+
         def plan(organization, path, force)
           action_subject organization
           manifest_update = organization.products.redhat.any?
@@ -20,12 +22,32 @@ module Actions
                 plan_action(Katello::Repository::RefreshRepository, repo)
               end
             end
+            plan_self
           end
         end
 
+        def failure_notification(plan)
+          ::Katello::UINotifications::Subscriptions::ManifestImportError.deliver!(
+            :subject => subject_organization,
+            :task => get_foreman_task(plan)
+          )
+        end
+
+        def success_notification(_plan)
+          ::Katello::UINotifications::Subscriptions::ManifestImportSuccess.deliver!(
+            subject_organization
+          )
+        end
+
         def humanized_name
           _("Import Manifest")
         end
+
+        def finalize
+          subject_organization.update_attributes!(
+            :manifest_refreshed_at => Time.now,
+            :audit_comment => _('Manifest imported'))
+        end
       end
     end
   end