katello 3.18.5 → 4.0.0.rc1

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

@@ -0,0 +1,99 @@
+module Katello
+  module EventDaemon
+    class Runner
+      STATUS_CACHE_KEY = "katello_event_daemon_status".freeze
+      @services = {}
+      @cache = ActiveSupport::Cache::MemoryStore.new
+
+      class << self
+        def initialize
+          FileUtils.touch(lock_file)
+        end
+
+        def settings
+          SETTINGS[:katello][:event_daemon]
+        end
+
+        def pid
+          return unless pid_file && File.exist?(pid_file)
+
+          File.open(pid_file) { |f| f.read.to_i }
+        end
+
+        def pid_file
+          pid_dir.join('katello_event_daemon.pid')
+        end
+
+        def pid_dir
+          Rails.root.join('tmp', 'pids')
+        end
+
+        def lock_file
+          Rails.root.join('tmp', 'katello_event_daemon.lock')
+        end
+
+        def write_pid_file
+          return unless pid_file
+
+          FileUtils.mkdir_p(pid_dir)
+          File.open(pid_file, 'w') { |f| f.puts Process.pid }
+        end
+
+        def stop
+          return unless pid == Process.pid
+          @monitor_thread.kill
+          @cache.clear
+          @services.values.each(&:close)
+          File.unlink(pid_file) if pid_file && File.exist?(pid_file)
+        end
+
+        def start
+          return unless runnable?
+          lockfile = File.open(lock_file, 'r')
+          begin
+            lockfile.flock(File::LOCK_EX)
+            return if started? # ensure it wasn't started while we waited for the lock
+            start_monitor_thread
+            write_pid_file
+
+            at_exit do
+              stop
+            end
+
+            Rails.logger.info("Katello event daemon started process=#{Process.pid}")
+          ensure
+            lockfile.flock(File::LOCK_UN)
+          end
+        end
+
+        def started?
+          Process.kill(0, pid)
+          true
+        rescue Errno::ESRCH, TypeError # process no longer exists or we had no PID cached
+          false
+        end
+
+        def start_monitor_thread
+          @monitor_thread = Thread.new do
+            Katello::EventDaemon::Monitor.new(@services).start
+          end
+        end
+
+        def runnable?
+          # avoid accessing the disk on each request
+          @cache.fetch('katello_event_daemon_runnable', expires_in: 1.minute) do
+            !started? && settings[:enabled] && !::Foreman.in_rake? && !Rails.env.test?
+          end
+        end
+
+        def register_service(name, klass)
+          @services[name] = klass
+        end
+
+        def service_status(service_name = nil)
+          Rails.cache.read(STATUS_CACHE_KEY)&.dig(service_name)
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/logging.rb

@@ -10,5 +10,37 @@ module Katello
 
       logger.send(level, "#{message} #{data_string}")
     end
+
+    class Timer
+      def initialize(key = "default")
+        @key = key
+        @start_time = Time.now
+        Thread.current[:timers] ||= {}
+        Thread.current[:timers][key] = self
+      end
+
+      def start
+        Rails.logger.info "Timer #{@key} already started; resetting start time" if @start_time
+        Rails.logger.info "Timer #{@key} starting at #{Time.now}"
+        @start_time = Time.now
+        self
+      end
+
+      def stop
+        fail ::StandardError, "Timer #{@key} is not started" unless @start_time
+        duration = (Time.now - @start_time).truncate(2)
+        @start_time = nil
+        Rails.logger.info "Timer #{@key} stopping at #{Time.now}: #{duration} sec"
+      end
+
+      def self.find_by_key(key)
+        if Thread.current&.[](:timers)&.[](key)
+          Thread.current[:timers][key]
+        else
+          Rails.logger.warn "Timer #{key} not found on current thread; creating a new timer"
+          self.new(key)
+        end
+      end
+    end
   end
 end

data/app/lib/katello/messaging/connection.rb

@@ -2,13 +2,7 @@ module Katello
   module Messaging
     class Connection
       def self.create(connection_class:, settings:)
-        connection = connection_class.new(settings: settings)
-
-        at_exit do
-          connection.close
-        end
-
-        connection
+        connection_class.new(settings: settings)
       end
     end
   end

data/app/lib/katello/util/pulpcore_content_filters.rb

@@ -8,7 +8,7 @@ module Katello
       def filter_package_groups_by_pulp_href(package_groups, package_pulp_hrefs)
         rpms = Katello::Rpm.where(:pulp_id => package_pulp_hrefs)
         package_groups.reject do |package_group|
-          (package_group.package_names - rpms.pluck(:name)).any?
+          (package_group.package_names & rpms.pluck(:name)).empty?
         end
       end
 

data/app/lib/katello/validators/content_view_puppet_module_validator.rb

@@ -1,7 +1,7 @@
 module Katello
   module Validators
     class ContentViewPuppetModuleValidator < ActiveModel::Validator
-      def validate(record)
+      def validate(record) # rubocop:disable Metrics/CyclomaticComplexity
         if record.uuid.blank? && (record.name.blank? || record.author.blank?)
           record.errors[:base] << _("Invalid puppet module parameters specified. \
                                     Either 'uuid' or 'name' and 'author' must be specified.")

data/app/models/katello/activation_key.rb

@@ -1,8 +1,8 @@
 module Katello
   class ActivationKey < Katello::Model
     audited :except => [:cp_id], :associations => [:host_collections]
-    include Glue::Candlepin::ActivationKey if SETTINGS[:katello][:use_cp]
-    include Glue if SETTINGS[:katello][:use_cp]
+    include Glue::Candlepin::ActivationKey
+    include Glue
     include Katello::Authorization::ActivationKey
     include ForemanTasks::Concerns::ActionSubject
     include ScopedSearchExtensions

data/app/models/katello/candlepin/repository_mapper.rb

@@ -114,7 +114,7 @@ module Katello
       end
 
       def suse?
-        content.content_type == Repository::YUM_TYPE && !!path.downcase.match(/suse/) # rubocop:disable Style/DoubleNegation
+        content.content_type == Repository::YUM_TYPE && !!path.downcase.match(/suse/)
       end
 
       def file?

data/app/models/katello/concerns/hostgroup_extensions.rb

@@ -107,9 +107,7 @@ module Katello
         return true unless operatingsystem
 
         if operatingsystem.respond_to? :kickstart_repos
-          operatingsystem.kickstart_repos(self, content_facet: content_facet).any? do |repo|
-            repo[:id] == (content_facet&.kickstart_repository_id || content_facet&.kickstart_repository&.id)
-          end
+          return operatingsystem.kickstart_repos(self).any? { |repo| repo[:id] == (content_facet&.kickstart_repository_id || content_facet&.kickstart_repository&.id) }
         end
       end
 
@@ -128,7 +126,7 @@ module Katello
           facet_model = Facets.registered_facets[facet].hostgroup_configuration.model
           value = facet_model.where.not(attribute => nil).joins(:hostgroup).merge(
             ::Hostgroup.where(id: self.ancestor_ids).reorder(ancestry: :desc)
-          ).limit(1).pluck(attribute).first
+          ).limit(1).pluck(attribute)
         end
         value
       end

data/app/models/katello/concerns/organization_extensions.rb

@@ -9,8 +9,8 @@ module Katello
 
         include ForemanTasks::Concerns::ActionSubject
         prepend ForemanTasks::Concerns::ActionTriggering
-        include Glue::Candlepin::Owner if SETTINGS[:katello][:use_cp]
-        include Glue if SETTINGS[:katello][:use_cp]
+        include Glue::Candlepin::Owner
+        include Glue
 
         include Katello::Authorization::Organization
         include Ext::LabelFromName

data/app/models/katello/concerns/pulp_database_unit.rb

@@ -218,18 +218,6 @@ module Katello
       def db_values(new_ids, pulp_id_href_map, repository)
         new_ids.map { |unit_id| [unit_id.to_i, pulp_id_href_map.dig(unit_id), repository.id.to_i, Time.now.utc.to_s(:db), Time.now.utc.to_s(:db)].compact }
       end
-
-      def unmigrated_content
-        self.where(migrated_pulp3_href: nil, ignore_missing_from_migration: false)
-      end
-
-      def missing_migrated_content #missing or corrupted content that could not be migrated
-        self.where(migrated_pulp3_href: nil, missing_from_migration: true, ignore_missing_from_migration: false)
-      end
-
-      def ignored_missing_migrated_content
-        self.where(migrated_pulp3_href: nil, missing_from_migration: true, ignore_missing_from_migration: true)
-      end
     end
   end
 end

data/app/models/katello/concerns/redhat_extensions.rb

@@ -42,11 +42,10 @@ module Katello
         end
       end
 
-      def kickstart_repos(host, content_facet: nil)
-        distros = distribution_repositories(host, content_facet: content_facet).where(distribution_bootable: true)
-        content_facet ||= host.content_facet
-        if distros && content_facet&.content_source
-          distros.map { |distro| distro.to_hash(content_facet.content_source) }
+      def kickstart_repos(host)
+        distros = distribution_repositories(host).where(distribution_bootable: true)
+        if distros && host&.content_facet&.content_source
+          distros.map { |distro| distro.to_hash(host.content_facet.content_source) }
         else
           []
         end
@@ -66,10 +65,10 @@ module Katello
         end
       end
 
-      def distribution_repositories(host, content_facet: nil)
-        content_facet ||= host.content_facet
-        content_view = content_facet.try(:content_view) || host.try(:content_view)
-        lifecycle_environment = content_facet.try(:lifecycle_environment) || host.try(:lifecycle_environment)
+      def distribution_repositories(host)
+        content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
+        lifecycle_environment = host.try(:content_facet).try(:lifecycle_environment) || host.try(:lifecycle_environment)
+
         if content_view && lifecycle_environment && host.os && host.architecture
           Katello::Repository.in_environment(lifecycle_environment).in_content_views([content_view]).
               where(:distribution_arch => host.architecture.name).

data/app/models/katello/concerns/smart_proxy_extensions.rb

@@ -101,6 +101,10 @@ module Katello
         end
       end
 
+      def update_unauthenticated_repo_list(repo_names)
+        ProxyAPI::ContainerGateway.new(url: self.url).unauthenticated_repository_list("repositories": repo_names)
+      end
+
       def puppet_path
         self[:puppet_path] || update_puppet_path
       end
@@ -348,6 +352,26 @@ module Katello
         end
       end
 
+      def repos_in_env_cv(environment = nil, content_view = nil)
+        repos = Katello::Repository
+        repos = repos.in_environment(environment) if environment
+        repos = repos.in_content_views([content_view]) if content_view
+        repos
+      end
+
+      def repos_in_sync_history
+        smart_proxy_sync_histories.map { |sync_history| sync_history.repository }
+      end
+
+      def current_repositories_data(environment = nil, content_view = nil)
+        return repos_in_sync_history unless (environment || content_view)
+        repos_in_sync_history & repos_in_env_cv(environment, content_view)
+      end
+
+      def repos_pending_sync(environment = nil, content_view = nil)
+        repos_in_env_cv(environment, content_view) - repos_in_sync_history
+      end
+
       def smart_proxy_service
         @smart_proxy_service ||= Pulp::SmartProxyRepository.new(self)
       end

data/app/models/katello/content_view.rb

@@ -241,6 +241,10 @@ module Katello
       environments.include?(env)
     end
 
+    apipie :method, 'Returns the Katello::ContentViewVersion for a given Lifecycle Environment' do
+      required :env, 'Katello::KTEnvironment', desc: 'a __Katello::KTEnvironment__ object for which we load the __Katello::ContentViewVersion__ object'
+      returns 'Katello::ContentViewVersion'
+    end
     def version(env)
       self.versions.in_environment(env).order("#{Katello::ContentViewVersion.table_name}.id ASC").readonly(false).last
     end
@@ -760,7 +764,7 @@ module Katello
       prop_group :katello_basic_props, Katello::Model, meta: { friendly_name: 'Content View' }
     end
     class Jail < ::Safemode::Jail
-      allow :name, :label
+      allow :name, :label, :version
     end
   end
 end

data/app/models/katello/content_view_environment.rb

@@ -2,8 +2,8 @@ module Katello
   class ContentViewEnvironment < Katello::Model
     audited :associated_with => :content_view
     include ForemanTasks::Concerns::ActionSubject
-    include Glue::Candlepin::Environment if SETTINGS[:katello][:use_cp]
-    include Glue if SETTINGS[:katello][:use_cp]
+    include Glue::Candlepin::Environment
+    include Glue
     include Authorization::ContentViewEnvironment
 
     belongs_to :content_view, :class_name => "Katello::ContentView", :inverse_of => :content_view_environments

data/app/models/katello/content_view_puppet_environment.rb

@@ -1,8 +1,8 @@
 module Katello
   class ContentViewPuppetEnvironment < Katello::Model
     include ForemanTasks::Concerns::ActionSubject
-    include Glue::Pulp::Repo if SETTINGS[:katello][:use_pulp]
-    include Glue if SETTINGS[:katello][:use_pulp]
+    include Glue::Pulp::Repo
+    include Glue
 
     belongs_to :environment, :class_name => "Katello::KTEnvironment",
                              :inverse_of => :content_view_puppet_environments

data/app/models/katello/content_view_version.rb

@@ -322,7 +322,8 @@ module Katello
     end
 
     def content_counts_map
-      return {} if content_counts.blank?
+      # if its empty, calculate it on demand
+      update_content_counts! if content_counts.blank?
       counts = Hash[content_counts.map { |key, value| ["#{key}_count", value] }]
       counts.merge("module_stream_count" => counts["modulemd_count"],
                    "package_count" => counts["rpm_count"],

data/app/models/katello/content_view_version_export_history.rb

@@ -2,13 +2,24 @@ module Katello
   class ContentViewVersionExportHistory < Katello::Model
     include Authorization::ContentViewVersionExportHistory
 
+    COMPLETE = "complete".freeze
+    INCREMENTAL = "incremental".freeze
+    EXPORT_TYPES = [COMPLETE, INCREMENTAL].freeze
+
     belongs_to :content_view_version, :class_name => "Katello::ContentViewVersion", :inverse_of => :export_histories
     validates_lengths_from_database
     validates :content_view_version_id, :presence => true
     validates :destination_server, :uniqueness => { :scope => [:content_view_version_id, :destination_server, :path] }
+    validates :export_type, :inclusion => { :in => EXPORT_TYPES,
+                                            :allow_blank => false,
+                                            :message => _("Invalid export_type from one of the following: %s" % EXPORT_TYPES.join(', '))
+                                          }
+
     validates :metadata, :presence => true
     serialize :metadata, Hash
 
+    before_validation :set_export_type, :if => -> { export_type.blank? }
+
     scope :with_organization_id, ->(organization_id) do
       where(:content_view_version_id => ContentViewVersion.with_organization_id(organization_id))
     end
@@ -20,10 +31,19 @@ module Katello
     scoped_search :on => :content_view_id, :relation => :content_view_version, :validator => ScopedSearch::Validators::INTEGER, :only_explicit => true
     scoped_search :on => :content_view_version_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
     scoped_search :on => :id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :export_type, :rename => :type, :complete_value => EXPORT_TYPES
 
     def self.latest(content_view, destination_server: nil)
       where(content_view_version: content_view.versions,
             destination_server: destination_server).order(:created_at).last
     end
+
+    def export_type_from_metadata
+      cvve.metadata[:incremental] ? INCREMENTAL : COMPLETE
+    end
+
+    def set_export_type
+      self.export_type = export_type_from_metadata
+    end
   end
 end

data/app/models/katello/erratum.rb

@@ -173,9 +173,11 @@ module Katello
       property :package_names, array_of: String, desc: 'Returns names of packages the errata can be applied to'
       property :cves, array_of: 'ErratumCve', desc: 'Returns CVEs associated with the errata'
       property :reboot_suggested, one_of: [true, false], desc: 'Returns true if reboot is suggested after errata applying, false otherwise'
+      property :title, String, desc: 'Returns the errata title, e.g. "Important: net-snmp security update"'
+      property :summary, String, desc: 'Returns the errata summary, the length can very, it is usually in range of 60 to 1000 characters. It can include empty line characters.'
     end
     class Jail < ::Safemode::Jail
-      allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested
+      allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested, :title, :summary
     end
   end
 end

data/app/models/katello/file_unit.rb

@@ -13,10 +13,6 @@ module Katello
       order(:name)
     end
 
-    def filename
-      path
-    end
-
     def self.total_for_repositories(repos)
       self.in_repositories(repos).count
     end

data/app/models/katello/glue/candlepin/pool.rb

@@ -92,6 +92,8 @@ module Katello
       end
 
       # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def import_data(index_hosts_and_activation_keys = false)
         pool_attributes = {}.with_indifferent_access
         pool_json = self.backend_data

data/app/models/katello/glue/pulp/repo.rb

@@ -113,12 +113,6 @@ module Katello
         backend_service(capsule).generate_distributors
       end
 
-      def populate_from(repos_map)
-        found = repos_map[self.pulp_id]
-        prepopulate(found) if found
-        !found.nil?
-      end
-
       def package_group_count
         content_unit_counts = 0
         if self.pulp_repo_facts

data/app/models/katello/glue/pulp/repos.rb

@@ -12,27 +12,6 @@ module Katello
       "#{path_prefix}/#{path}"
     end
 
-    def self.prepopulate!(products, environment, repos = [], content_view = nil)
-      if content_view.nil?
-        if environment.library?
-          content_view = environment.default_content_view
-        else
-          fail "No content view specified for a Non library environment #{environment.inspect}"
-        end
-      end
-
-      items = Katello.pulp_server.extensions.repository.search_by_repository_ids(Repository.in_environment(environment).pluck(:pulp_id))
-      full_repos = {}
-      items.each { |item| full_repos[item["id"]] = item }
-
-      products.each do |prod|
-        prod.repos(environment, content_view).each do |repo|
-          repo.populate_from(full_repos)
-        end
-      end
-      repos.each { |repo| repo.populate_from(full_repos) }
-    end
-
     module InstanceMethods
       def distributions(env)
         to_ret = []
@@ -125,7 +104,7 @@ module Katello
             AND inner_select.resource_id = locks_foreman_tasks_tasks.resource_id")
           .distinct
 
-        max_per_repoid.map { |x| [x.resource_id, x] }.to_h
+        max_per_repoid.index_by { |x| [x.resource_id, x] }
       end
 
       def sync_state_aggregated

data/app/models/katello/host/content_facet.rb

@@ -31,21 +31,43 @@ module Katello
       validates :host, :presence => true, :allow_blank => false
       validates_with Validators::ContentViewEnvironmentValidator
 
+      def bindable_types
+        [
+          {
+            type: Repository::DEB_TYPE,
+            matcher: '/pulp/deb/',
+            paths: []
+          },
+          {
+            type: Repository::YUM_TYPE,
+            matcher: '/pulp/repos/',
+            paths: []
+          }
+        ]
+      end
+
       def update_repositories_by_paths(paths)
-        prefixes = %w(/pulp/deb/ /pulp/repos/ /pulp/content/)
+        bindable_paths = bindable_types
         relative_paths = []
 
-        # paths == ["/pulp/repos/Default_Organization/Library/custom/Test_product/test2"]
-        paths.each do |path|
-          if (prefix = prefixes.find { |pre| path.start_with?(pre) })
-            relative_paths << path.gsub(prefix, '')
-          else
-            Rails.logger.warn("System #{self.host.name} (#{self.host.id}) requested binding to repo with unknown prefix. #{path}")
+        # paths == ["/pulp/repos/Default_Organization/Library/custom/Test_product/test2",
+        # "/pulp/repos/Default_Organization/Library/custom/Test_product/My_repo"]
+        paths.each do |absolute_path|
+          bindable_paths.each do |supported|
+            relative_path = absolute_path.gsub(supported[:matcher], '') # remove e.g. '/pulp/repos/' from beginning of string
+            relative_paths << relative_path unless relative_path == absolute_path
+            if absolute_path.starts_with?(supported[:matcher])
+              supported[:paths] << relative_path
+              break
+            end
           end
         end
 
-        repos = Repository.where(relative_path: relative_paths)
-        relative_paths -= repos.pluck(:relative_path) # remove relative paths that match our repos
+        repos = bindable_paths.flat_map do |supported|
+          repos = Repository.joins(:root).where(RootRepository.table_name => {content_type: supported[:type]}, relative_path: supported[:paths])
+          relative_paths -= repos.pluck(:relative_path) # remove relative paths that match our repos
+          repos
+        end
 
         # Any leftover relative paths do not match the repos we've just retrieved from the db,
         # so we should log warnings about them.

data/app/models/katello/ping.rb

@@ -9,7 +9,7 @@ module Katello
         SETTINGS[:katello][:use_pulp_2_for_content_type].nil? || (!SETTINGS[:katello][:use_pulp_2_for_content_type][:yum] &&
         !SETTINGS[:katello][:use_pulp_2_for_content_type][:docker] &&
         !SETTINGS[:katello][:use_pulp_2_for_content_type][:file]) ||
-        File.exist?('/etc/systemd/system/multi-user.target.wants/pulpcore-api.service')
+        system('systemctl is-enabled pulpcore-api.service')
       end
 
       def services(capsule_id = nil)
@@ -23,18 +23,25 @@ module Katello
         services
       end
 
+      # Calls "status" services in all backend engines.
       def ping(services: nil, capsule_id: nil)
-        ping_services_for_capsule(services, capsule_id)
-      end
+        services ||= self.services(capsule_id)
+        result = {}
+        services.each { |service| result[service] = {} }
 
-      def ping!(services: nil, capsule_id: nil)
-        result = ping_services_for_capsule(services, capsule_id)
+        ping_pulp3_without_auth(result[:pulp3], capsule_id) if result.include?(:pulp3)
+        ping_pulp_without_auth(result[:pulp], capsule_id) if result.include?(:pulp)
+        ping_candlepin_without_auth(result[:candlepin]) if result.include?(:candlepin)
 
-        if result[:status] != OK_RETURN_CODE
-          failed_names = failed_services(result).keys
-          fail("The following services have not been started or are reporting errors: #{failed_names.join(', ')}")
-        end
+        ping_pulp_with_auth(result[:pulp_auth], result[:pulp][:status]) if result.include?(:pulp_auth)
+        ping_candlepin_with_auth(result[:candlepin_auth]) if result.include?(:candlepin_auth)
+        ping_foreman_tasks(result[:foreman_tasks]) if result.include?(:foreman_tasks)
+        ping_katello_events(result[:katello_events]) if result.include?(:katello_events)
+        ping_candlepin_events(result[:candlepin_events]) if result.include?(:candlepin_events)
 
+        # set overall status result code
+        result = {:services => result}
+        result[:status] = result[:services].each_value.any? { |v| v[:status] == FAIL_RETURN_CODE } ? FAIL_RETURN_CODE : OK_RETURN_CODE
         result
       end
 
@@ -49,7 +56,7 @@ module Katello
         running = status&.dig(:running)
 
         if running
-          result[:message] = "#{status[:processed_count]} Processed, #{status[:failed_count]} Failed"
+          result[:message] = "#{status[:processed_count].to_i} Processed, #{status[:failed_count].to_i} Failed"
         else
           result[:status] = FAIL_RETURN_CODE
           result[:message] = _("Not running")
@@ -58,14 +65,14 @@ module Katello
 
       def ping_katello_events(result)
         exception_watch(result) do
-          status = Katello::EventMonitor::PollerThread.status(refresh: false)
+          status = Katello::EventDaemon::Runner.service_status(:katello_events)
           event_daemon_status(status, result)
         end
       end
 
       def ping_candlepin_events(result)
         exception_watch(result) do
-          status = Katello::CandlepinEventListener.status(refresh: false)
+          status = Katello::EventDaemon::Runner.service_status(:candlepin_events)
           event_daemon_status(status, result)
         end
       end
@@ -214,33 +221,6 @@ module Katello
 
       private
 
-      def failed_services(result)
-        result[:services].reject do |_name, details|
-          details[:status] != OK_RETURN_CODE
-        end
-      end
-
-      def ping_services_for_capsule(services, capsule_id)
-        services ||= self.services(capsule_id)
-        result = {}
-        services.each { |service| result[service] = {} }
-
-        ping_pulp3_without_auth(result[:pulp3], capsule_id) if result.include?(:pulp3)
-        ping_pulp_without_auth(result[:pulp], capsule_id) if result.include?(:pulp)
-        ping_candlepin_without_auth(result[:candlepin]) if result.include?(:candlepin)
-
-        ping_pulp_with_auth(result[:pulp_auth], result[:pulp][:status]) if result.include?(:pulp_auth)
-        ping_candlepin_with_auth(result[:candlepin_auth]) if result.include?(:candlepin_auth)
-        ping_foreman_tasks(result[:foreman_tasks]) if result.include?(:foreman_tasks)
-        ping_katello_events(result[:katello_events]) if result.include?(:katello_events)
-        ping_candlepin_events(result[:candlepin_events]) if result.include?(:candlepin_events)
-
-        # set overall status result code
-        result = {:services => result}
-        result[:status] = result[:services].each_value.any? { |v| v[:status] == FAIL_RETURN_CODE } ? FAIL_RETURN_CODE : OK_RETURN_CODE
-        result
-      end
-
       def fetch_proxy(capsule_id)
         capsule_id ? SmartProxy.unscoped.find(capsule_id) : SmartProxy.pulp_primary
       end