katello 4.0.3 → 4.1.0.rc1

data/app/lib/actions/pulp3/content_view_version/create_export_history.rb

@@ -0,0 +1,57 @@
+module Actions
+  module Pulp3
+    module ContentViewVersion
+      class CreateExportHistory < Actions::EntryAction
+        input_format do
+          param :smart_proxy_id, Integer
+          param :exporter_data, Hash
+          param :content_view_version_id, Integer
+          param :from_content_view_version_id, Integer
+          param :destination_server, String
+        end
+
+        output_format do
+          param :export_history_id, Integer
+          param :path, String
+          param :exported_file_checksum, String
+        end
+
+        def run
+          smart_proxy = ::SmartProxy.find(input[:smart_proxy_id])
+          api = ::Katello::Pulp3::Api::Core.new(smart_proxy)
+          export_data = api.export_api.list(input[:exporter_data][:pulp_href]).results.first
+          output[:exported_file_checksum] = export_data.output_file_info
+          file_name = output[:exported_file_checksum].first&.first
+          path = File.dirname(file_name.to_s)
+          output[:path] = path
+          cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
+
+          export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.new(
+                                                     content_view_version: cvv,
+                                                     smart_proxy: smart_proxy,
+                                                     from_content_view_version: from_cvv).generate_metadata
+
+          toc_path_info = output[:exported_file_checksum].find { |item| item.first.end_with?("toc.json") }
+          export_metadata[:toc] = File.basename(toc_path_info.first)
+
+          history = ::Katello::ContentViewVersionExportHistory.create!(
+            content_view_version_id: input[:content_view_version_id],
+            destination_server: input[:destination_server],
+            path: path,
+            metadata: export_metadata,
+            audit_comment: ::Katello::ContentViewVersionExportHistory.generate_audit_comment(content_view_version: cvv,
+                                                                                             user: User.current,
+                                                                                             from_version: from_cvv,
+                                                                                             metadata: export_metadata)
+          )
+          output[:export_history_id] = history.id
+        end
+
+        def humanized_name
+          _("Create Export History")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/content_view_version/create_import_history.rb

@@ -0,0 +1,34 @@
+module Actions
+  module Pulp3
+    module ContentViewVersion
+      class CreateImportHistory < Actions::EntryAction
+        input_format do
+          param :content_view_version_id, Integer
+          param :path, String
+          param :metadata, Hash
+          param :content_view_name, String
+        end
+
+        output_format do
+          param :import_history_id, Integer
+        end
+
+        def run
+          history = ::Katello::ContentViewVersionImportHistory.create!(
+            content_view_version_id: input[:content_view_version_id],
+            path: input[:path],
+            metadata: input[:metadata],
+            audit_comment: ::Katello::ContentViewVersionImportHistory.generate_audit_comment(path: input[:path],
+                                                                                             user: User.current,
+                                                                                             content_view_name: input[:content_view_name])
+          )
+          output[:import_history_id] = history.id
+        end
+
+        def humanized_name
+          _("Create Import History")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/content_view_version/copy_version_units_to_library.rb

@@ -7,12 +7,11 @@ module Actions
             concurrence do
               content_view_version.importable_repositories.each do |repo|
                 sequence do
-                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent, repo, SmartProxy.pulp_primary!,
+                  plan_action(Actions::Pulp3::Repository::CopyContent, repo, SmartProxy.pulp_primary!,
                                                     repo.library_instance,
                                                     copy_all: true,
                                                     mirror: content_view_version.content_view.library_import?)
-                  plan_action(Actions::Pulp3::Repository::SaveVersion, repo.library_instance,
-                                tasks: copy_action.output[:pulp_tasks])
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, repo.library_instance)
                   plan_action(Katello::Repository::IndexContent, id: repo.library_instance_id)
                   plan_action(Katello::Repository::MetadataGenerate, repo.library_instance, :force => true)
                 end

data/app/lib/actions/pulp3/orchestration/content_view_version/export.rb

@@ -16,81 +16,64 @@ module Actions
             param :exported_file_checksum, Hash
             param :export_path, String
           end
-
-          # rubocop:disable Metrics/MethodLength
           def plan(content_view_version:, destination_server: nil,
                    chunk_size: nil, from_history: nil,
                    validate_incremental: true,
                    fail_on_missing_content: false)
-            action_subject(content_view_version)
-            unless File.directory?(Setting['pulpcore_export_destination'])
-              fail ::Foreman::Exception, N_("Unable to export. 'pulpcore_export_destination' setting is not set to a valid directory.")
-            end
 
             sequence do
               smart_proxy = SmartProxy.pulp_primary!
               from_content_view_version = from_history&.content_view_version
               export_service = ::Katello::Pulp3::ContentViewVersion::Export.new(
-                                                     smart_proxy: smart_proxy,
-                                                     content_view_version: content_view_version,
-                                                     destination_server: destination_server,
-                                                     from_content_view_version: from_content_view_version)
+                  smart_proxy: smart_proxy,
+                  content_view_version: content_view_version,
+                  destination_server: destination_server,
+                  from_content_view_version: from_content_view_version)
               export_service.validate!(fail_on_missing_content: fail_on_missing_content,
                                        validate_incremental: validate_incremental)
 
               action_output = plan_action(::Actions::Pulp3::ContentViewVersion::CreateExporter,
-                                     content_view_version_id: content_view_version.id,
-                                     smart_proxy_id: smart_proxy.id,
-                                     destination_server: destination_server).output
+                                          content_view_version_id: content_view_version.id,
+                                          smart_proxy_id: smart_proxy.id,
+                                          destination_server: destination_server).output
 
               plan_action(::Actions::Pulp3::ContentViewVersion::Export,
-                                     content_view_version_id: content_view_version.id,
-                                     smart_proxy_id: smart_proxy.id,
-                                     exporter_data: action_output[:exporter_data],
-                                     chunk_size: chunk_size,
-                                     from_content_view_version_id: from_content_view_version&.id)
+                          content_view_version_id: content_view_version.id,
+                          smart_proxy_id: smart_proxy.id,
+                          exporter_data: action_output[:exporter_data],
+                          chunk_size: chunk_size,
+                          from_content_view_version_id: from_content_view_version&.id)
+
+              history_output = plan_action(
+                  ::Actions::Pulp3::ContentViewVersion::CreateExportHistory,
+                  smart_proxy_id: smart_proxy.id,
+                  exporter_data: action_output[:exporter_data],
+                  pulp_href: action_output[:exporter_data][:pulp_href],
+                  content_view_version_id: content_view_version.id,
+                  from_content_view_version_id: from_content_view_version&.id,
+                  destination_server: destination_server
+              ).output
+
+              plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
+                          smart_proxy_id: smart_proxy.id,
+                          exporter_data: action_output[:exporter_data])
 
               plan_self(exporter_data: action_output[:exporter_data], smart_proxy_id: smart_proxy.id,
                         destination_server: destination_server,
                         content_view_version_id: content_view_version.id,
-                        from_content_view_version_id: from_content_view_version&.id)
-
-              plan_action(::Actions::Pulp3::ContentViewVersion::DestroyExporter,
-                            smart_proxy_id: smart_proxy.id,
-                            exporter_data: action_output[:exporter_data])
+                        from_content_view_version_id: from_content_view_version&.id,
+                        export_history_id: history_output[:export_history_id],
+                        exported_file_checksum: history_output[:exported_file_checksum],
+                        export_path: history_output[:path])
             end
           end
 
           def run
-            smart_proxy = ::SmartProxy.find(input[:smart_proxy_id])
-            api = ::Katello::Pulp3::Api::Core.new(smart_proxy)
-            export_data = api.export_api.list(input[:exporter_data][:pulp_href]).results.first
-            output[:exported_file_checksum] = export_data.output_file_info
-            file_name = output[:exported_file_checksum].first&.first
-            path = File.dirname(file_name.to_s)
-            output[:export_path] = path
-            cvv = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
-            from_cvv = ::Katello::ContentViewVersion.find(input[:from_content_view_version_id]) unless input[:from_content_view_version_id].blank?
-
-            export_metadata = ::Katello::Pulp3::ContentViewVersion::Export.new(
-                                                       content_view_version: cvv,
-                                                       smart_proxy: smart_proxy,
-                                                       from_content_view_version: from_cvv).generate_metadata
-
-            toc_path_info = output[:exported_file_checksum].find { |item| item.first.end_with?("toc.json") }
-            export_metadata[:toc] = File.basename(toc_path_info.first)
-
-            history = ::Katello::ContentViewVersionExportHistory.create!(
-              content_view_version_id: input[:content_view_version_id],
-              destination_server: input[:destination_server],
-              path: path,
-              metadata: export_metadata
+            output.update(
+                export_history_id: input[:export_history_id],
+                export_path: input[:export_path],
+                exported_file_checksum: input[:exported_file_checksum]
             )
-            output[:export_history_id] = history.id
-          end
-
-          def humanized_name
-            _("Export")
           end
 
           def rescue_strategy

data/app/lib/actions/pulp3/orchestration/content_view_version/export_library.rb

@@ -13,12 +13,12 @@ module Actions
             content_view = ::Katello::Pulp3::ContentViewVersion::Export.find_library_export_view(destination_server: destination_server,
                                                                            organization: organization,
                                                                            create_by_default: true)
-            repo_ids_in_library = organization.default_content_view_version.repositories.yum_type.immediate.pluck(:id)
+            repo_ids_in_library = organization.default_content_view_version.repositories.exportable.immediate_or_none.pluck(:id)
             content_view.update!(repository_ids: repo_ids_in_library)
 
             sequence do
               publish_action = plan_action(::Actions::Katello::ContentView::Publish, content_view, '')
-              export_action = plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Export,
+              export_action = plan_action(Actions::Katello::ContentViewVersion::Export,
                                           content_view_version: publish_action.version,
                                           destination_server: destination_server,
                                           chunk_size: chunk_size,

data/app/lib/actions/pulp3/orchestration/content_view_version/import.rb

@@ -26,10 +26,22 @@ module Actions
 
               plan_action(Actions::Pulp3::Repository::SaveVersions, content_view_version.importable_repositories.pluck(:id),
                           tasks: import_output[:pulp_tasks])
-
+              plan_action(
+                ::Actions::Pulp3::ContentViewVersion::CreateImportHistory,
+                content_view_version_id: content_view_version.id,
+                path: path,
+                metadata: metadata,
+                content_view_name: content_view_version.name
+              )
               plan_action(::Actions::Pulp3::ContentViewVersion::DestroyImporter,
                             smart_proxy_id: smart_proxy.id,
                             importer_data: importer_output[:importer_data])
+              plan_self(
+                content_view_name: content_view_version.name,
+                metadata: metadata,
+                path: path,
+                content_view_version_id: content_view_version.id
+              )
             end
           end
 

data/app/lib/actions/pulp3/orchestration/orphan_cleanup/remove_orphans.rb

@@ -2,7 +2,7 @@ module Actions
   module Pulp3
     module Orchestration
       module OrphanCleanup
-        class RemoveOrphans < Pulp3::Abstract
+        class RemoveOrphans < Pulp::Abstract
           def plan(proxy)
             if proxy.pulp3_enabled?
               sequence do

data/app/lib/actions/pulp3/orchestration/repository/sync.rb

@@ -6,6 +6,7 @@ module Actions
           include Actions::Helpers::OutputPropagator
           def plan(repository, smart_proxy, options)
             sequence do
+              plan_action(Actions::Pulp3::Repository::RefreshRemote, repository, smart_proxy)
               action_output = plan_action(Actions::Pulp3::Repository::Sync, repository, smart_proxy, options).output
 
               force_fetch_version = true if options[:optimize] == false

data/app/lib/actions/pulp3/repository/refresh_remote.rb

@@ -0,0 +1,17 @@
+module Actions
+  module Pulp3
+    module Repository
+      class RefreshRemote < Pulp3::AbstractAsyncTask
+        def plan(repository, smart_proxy)
+          plan_self(repository_id: repository.id, smart_proxy_id: smart_proxy.id)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          backend = repo.backend_service(smart_proxy)
+          backend.update_remote if backend.remote_needs_updates?
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/agent/client_message_handler.rb

@@ -34,17 +34,9 @@ module Katello
       private
 
       def handle_dynflow_event
-        return unless accepted? || result
-
-        task = ForemanTasks::Task.find_by_external_id(@dispatch_history.dynflow_execution_plan_id)
-
-        unless task
-          logger.info("Task external_id=#{@dispatch_history.dynflow_execution_plan_id} wasn't found. Skipping dynflow event dispatch")
-          return
-        end
-
-        unless task.result == 'pending'
-          logger.info("Task is no longer pending. Skipping dynflow event dispatch. task_result=#{task.result} external_id=#{@dispatch_history.dynflow_execution_plan_id} dispatch_history_id=#{@dispatch_history.id}")
+        task_exists = ForemanTasks::Task.exists?(external_id: @dispatch_history.dynflow_execution_plan_id, result: 'pending')
+        unless task_exists
+          logger.warn("Couldn't find pending task with external_id=#{@dispatch_history.dynflow_execution_plan_id} dispatch_history_id=#{@dispatch_history.id}")
           return
         end
 

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -2,40 +2,83 @@ module Katello
   module Concerns
     module BaseTemplateScopeExtensions
       extend ActiveSupport::Concern
+      extend ApipieDSL::Module
 
+      apipie :class, 'Base macros related to content hosts to use within a template' do
+        name 'Base Content'
+        sections only: %w[all reports provisioning jobs partition_tables]
+      end
+
+      apipie :method, 'Returns an erratum by ID' do
+        required :id, Integer, desc: 'Errata ID'
+        returns Object, desc: 'The erratum object'
+      end
       def errata(id)
         Katello::Erratum.in_repositories(Katello::Repository.readable).with_identifiers(id).map(&:attributes).first.slice!('created_at', 'updated_at')
       end
 
+      apipie :method, 'Returns subscriptions for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get subscriptions for'
+        returns array_of: 'Subscription', desc: 'Array with subscription object'
+      end
       def host_subscriptions(host)
         host.subscriptions
       end
 
+      apipie :method, 'Returns subscription names for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get subscriptions for'
+        returns array_of: String, desc: "Array with names of host's subscriptions"
+      end
       def host_subscriptions_names(host)
         host.subscriptions.map(&:name)
       end
 
+      apipie :method, 'Returns Red Hat subscription names for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get subscriptions for'
+        returns array_of: String, desc: "Array with names of host's subscriptions"
+      end
       def host_redhat_subscription_names(host)
         host.subscriptions.redhat.pluck(:name)
       end
 
+      apipie :method, 'Returns the count of Red Hat subscriptions consumed for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get subscriptions for'
+        returns Integer, desc: "Count of consumed Red Hat subscriptions"
+      end
       def host_redhat_subscriptions_consumed(host)
         presenter = ::Katello::HostSubscriptionsPresenter.new(host)
         presenter.subscriptions.select(&:redhat?).sum(&:quantity_consumed)
       end
 
+      apipie :method, 'Returns content facet for the host' do
+        desc "Content facet is an object containing the host's content-related metadata and associations"
+        required :host, 'Host::Managed', desc: 'Host object to get content facet for'
+        returns 'ContentFacet'
+      end
       def host_content_facet(host)
         host.content_facet
       end
 
+      apipie :method, 'Returns service level for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get service level for'
+        returns String, example: 'host_sla(host) #=> "Standard"'
+      end
       def host_sla(host)
         host_subscription_facet(host)&.service_level
       end
 
+      apipie :method, 'Returns installed products for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get products for'
+        returns array_of: 'Product', desc: "Array of installed product objects on the host"
+      end
       def host_products(host)
         host_subscription_facet(host)&.installed_products
       end
 
+      apipie :method, 'Returns installed product names for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get products for'
+        returns array_of: String, desc: 'Array with names of installed products on the host'
+      end
       def host_products_names(host)
         products = host_products(host)
         if products
@@ -45,52 +88,113 @@ module Katello
         end
       end
 
+      apipie :method, 'Returns the host collections the host belongs to' do
+        required :host, 'Host::Managed', desc: 'Host object to get the host collections for'
+        returns array_of: 'HostCollection', desc: "Array of the host collection objects the host belongs to"
+      end
       def host_collections(host)
         host.host_collections
       end
 
+      apipie :method, 'Returns names of the host collections the host belongs to' do
+        required :host, 'Host::Managed', desc: 'Host object to get the host collections for'
+        returns array_of: String, desc: 'Array with names of the host collections the host belongs to'
+      end
       def host_collections_names(host)
         host.host_collections.map(&:name)
       end
 
+      apipie :method, 'Returns subscription name of the pool' do
+        required :pool, 'Katello::Pool', desc: 'Pool object to get subscription name of'
+        returns String, desc: 'Name of the subscription'
+      end
       def sub_name(pool)
         return unless pool
         pool.subscription&.name
       end
 
+      apipie :method, 'Returns subscription SKU' do
+        required :pool, 'Katello::Pool', desc: 'Pool object to get subscription SKU of'
+        returns String, desc: "SKU's ID of the subscription"
+      end
       def sub_sku(pool)
         return unless pool
         pool.subscription&.cp_id
       end
 
+      apipie :method, 'Returns the smart proxy that the host was registered through' do
+        required :host, 'Host::Managed', desc: 'Host object to get smart proxy of'
+        returns String, desc: 'Hostname of the smart proxy'
+      end
       def registered_through(host)
         host_subscription_facet(host)&.registered_through
       end
 
+      apipie :method, 'Returns time the host was registered at' do
+        required :host, 'Host::Managed', desc: 'Host object to get registration time of'
+        returns 'ActiveSupport::TimeWithZone', desc: 'Registration time of the host'
+      end
       def registered_at(host)
         host_subscription_facet(host)&.registered_at
       end
 
+      apipie :method, 'Returns IDs of the applicable errata on the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get the applicable errata for'
+        returns array_of: Integer, desc: 'Array with applicable errata IDs of the host'
+      end
       def host_applicable_errata_ids(host)
         host.applicable_errata.map(&:errata_id)
       end
 
+      apipie :method, 'Returns filtered applicable errata for the host' do
+        required :host, 'Host::Managed', desc: 'Host object to get the applicable errata for'
+        optional :filter, String, desc: 'Filter to apply on applicable errata', default: ''
+        returns array_of: 'Erratum', desc: 'Filtered applicable errata for the host'
+      end
       def host_applicable_errata_filtered(host, filter = '')
         host.applicable_errata.includes(:cves).search_for(filter)
       end
 
+      apipie :method, 'Returns version of the latest applicable RPM package' do
+        required :host, 'Host::Managed', desc: 'Host object to get the applicable RPM package version on'
+        required :package, String, desc: 'Name of the package'
+        returns String, desc: 'Package version'
+      end
       def host_latest_applicable_rpm_version(host, package)
         host.applicable_rpms.where(name: package).order(:version_sortable).limit(1).pluck(:nvra).first
       end
 
+      apipie :method, 'Loads Pool objects' do
+        desc 'This macro returns a collection of Pools matching search criteria.
+          The collection is loaded in bulk, 1000 records at a time.'
+        keyword :search, String, desc: 'A search term to limit the resulting collection, using standard search syntax', default: ''
+        keyword :includes, Array, of: [String, Symbol], desc: 'An array of associations represented by strings or symbols, to be included in the SQL query. The list can be extended
+          from plugins and can not be fully documented here. Most used associations are :subscription, :products, :organization', default: nil
+        returns array_of: 'Pool', desc: 'The collection that can be iterated over using each_record'
+      end
       def load_pools(search: '', includes: nil)
         load_resource(klass: Pool.readable, search: search, permission: nil, includes: includes)
       end
 
+      apipie :method, 'Returns the last time the host checked in via RHSM' do
+        required :host, 'Host::Managed', desc: 'Host object to get the last time the host checked in'
+        returns 'ActiveSupport::TimeWithZone', desc: 'The last time the host checked in via RHSM'
+      end
       def last_checkin(host)
         host&.subscription_facet&.last_checkin
       end
 
+      apipie :method, 'Load errata applications' do
+        desc 'This macro returns a collection of task records relating to errata being applied.
+          The collection is loaded in bulk, 1000 records at a time.'
+        keyword :filter_errata_type, String, desc: "Errata type. One of: #{Katello::Erratum::TYPES.join(', ')}", default: nil
+        keyword :include_last_reboot, String, desc: "Set to 'yes' to include the last reboot time of each host", default: 'yes'
+        keyword :since, String, desc: 'Return errata applications after this date'
+        keyword :up_to, String, desc: 'Return errata applications before this date'
+        keyword :status, String, desc: 'Task status. One of: "pending", "success", "error", "warning"'
+        keyword :host_filter, String, desc: 'A filter term to limit the resulting collection, using standard filter syntax', default: nil
+        returns array_of: 'Erratum', desc: 'The collection that can be iterated over using each_record'
+      end
       # rubocop:disable Metrics/MethodLength
       # rubocop:disable Metrics/AbcSize
       # rubocop:disable Metrics/CyclomaticComplexity
@@ -101,13 +205,13 @@ module Katello
         filter_errata_type = filter_errata_type.presence || 'all'
         search_up_to = up_to.present? ? "ended_at < \"#{up_to}\"" : nil
         search_since = since.present? ? "ended_at > \"#{since}\"" : nil
-        search_result = status.present? ? "result = #{status}" : nil
+        search_result = status.present? && status != 'all' ? "result = #{status}" : nil
         search = [search_up_to, search_since, search_result].compact.join(' and ')
 
         if Katello.with_remote_execution?
-          condition = ["state != 'stoppped' AND (label = 'Actions::RemoteExecution::RunHostJob' AND templates.id = ?) OR label = 'Actions::Katello::Host::Erratum::Install'", RemoteExecutionFeature.feature('katello_errata_install').job_template_id]
+          condition = ["state != 'stopped' AND (label = 'Actions::RemoteExecution::RunHostJob' AND templates.id = ?) OR label = 'Actions::Katello::Host::Erratum::Install'", RemoteExecutionFeature.feature('katello_errata_install').job_template_id]
         else
-          condition = "state != 'stoppped' AND label = 'Actions::Katello::Host::Erratum::Install'"
+          condition = "state != 'stopped' AND label = 'Actions::Katello::Host::Erratum::Install'"
         end
 
         tasks = load_resource(klass: ForemanTasks::Task,
@@ -165,10 +269,20 @@ module Katello
       end
       # rubocop:enable Metrics/MethodLength
 
+      apipie :method, 'Converts package version to be sortable' do
+        required :version, String, desc: 'Version to convert'
+        returns String, desc: 'Sortable version of a package'
+        example 'For usage example please refer to **Host - compare content hosts packages** report template'
+      end
       def sortable_version(version)
         Util::Package.sortable_version(version)
       end
 
+      apipie :method, 'Returns true if Katello Agent infrastructure is enabled on the server'
+      def katello_agent_enabled?
+        Katello.with_katello_agent?
+      end
+
       private
 
       def host_subscription_facet(host)

data/app/lib/katello/errors.rb

@@ -1,11 +1,11 @@
 module Katello
   module Errors
+    class PingError < StandardError; end
+
     class InvalidActionOptionError < StandardError; end
 
     class InvalidRepositoryContent < StandardError; end
 
-    class InvalidPuppetModuleError < InvalidRepositoryContent; end
-
     class NotFound < StandardError; end
 
     class RegistrationError < StandardError; end
@@ -53,7 +53,7 @@ module Katello
 
     class PulpcoreMissingCapabilities < StandardError
       def message
-        _("A smart proxy seems to have been refreshed without pulpcore being running. Please refresh the smart proxy after ensuring that pulpcore services are running.")
+        _("A smart proxy seems to have been refreshed without pulpcore being running.  You may want to ")
       end
     end
 
@@ -91,14 +91,6 @@ module Katello
       end
     end
 
-    class PuppetConflictException < StandardError
-      attr_accessor :conflicts
-
-      def initialize(conflicts)
-        self.conflicts = conflicts
-      end
-    end
-
     class CandlepinError < StandardError
       # Return a CandlepinError with the displayMessage
       # as the message set it
@@ -112,6 +104,9 @@ module Katello
       end
     end
 
+    class CandlepinNotRunning < StandardError; end
+    class CandlepinPoolGone < CandlepinError; end
+
     class Pulp3Error < StandardError; end
     class Pulp3MigrationError < StandardError; end
 

data/app/lib/katello/event_daemon/monitor.rb

@@ -38,7 +38,6 @@ module Katello
             begin
               service_class.close
               service_class.run
-              sleep 0.1
               @service_statuses[service_name] = service_class.status
             rescue => error
               Rails.logger.error("Error occurred while starting #{service_class}")

data/app/lib/katello/event_daemon/runner.rb

@@ -17,7 +17,7 @@ module Katello
         def pid
           return unless pid_file && File.exist?(pid_file)
 
-          File.open(pid_file) { |f| f.read.to_i }
+          File.read(pid_file).to_i
         end
 
         def pid_file
@@ -36,7 +36,7 @@ module Katello
           return unless pid_file
 
           FileUtils.mkdir_p(pid_dir)
-          File.open(pid_file, 'w') { |f| f.puts Process.pid }
+          File.write(pid_file, Process.pid)
         end
 
         def stop