katello 4.0.3 → 4.1.0.rc1

data/app/models/katello/glue/provider.rb

@@ -97,10 +97,7 @@ module Katello
         data = Resources::Candlepin::UpstreamConsumer.export("#{url}#{upstream['uuid']}/export", upstream['idCert']['cert'],
                                                              upstream['idCert']['key'], ca_file)
 
-        File.open(zip_file_path, 'w') do |f|
-          f.binmode
-          f.write data
-        end
+        File.write(zip_file_path, data, mode: 'wb')
 
         return true
       end
@@ -144,7 +141,7 @@ module Katello
           prod_content_importer.import
         end
 
-        self.index_subscriptions(self.organization)
+        self.index_subscriptions
         prod_content_importer
       end
 
@@ -158,7 +155,7 @@ module Katello
         product
       end
 
-      def index_subscriptions(organization = nil)
+      def index_subscriptions
         Katello::Subscription.import_all(organization)
         Katello::Pool.import_all(organization, false)
       end

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

@@ -1,7 +1,6 @@
 module Katello
   module Glue::Pulp::Repo
     # TODO: move into submodules
-    # rubocop:disable Metrics/MethodLength
     def self.included(base)
       base.send :include, LazyAccessor
       base.send :include, InstanceMethods
@@ -74,6 +73,11 @@ module Katello
         pulp_repo_facts['content_unit_counts']['srpm']
       end
 
+      def uri
+        uri = URI.parse(SETTINGS[:katello][:pulp][:url])
+        "https://#{uri.host}/pulp/content/#{relative_path}"
+      end
+
       def to_hash
         pulp_repo_facts.merge(as_json).merge(:sync_state => sync_state)
       end
@@ -90,7 +94,6 @@ module Katello
           srpms.count != pulp_counts['srpm'].to_i ||
           errata.count != pulp_counts['erratum'].to_i ||
           package_groups.count != pulp_counts['package_group'].to_i ||
-          puppet_modules.count != pulp_counts['puppet_module'].to_i ||
           docker_manifests.count != pulp_counts['docker_manifest'].to_i ||
           docker_tags.count != pulp_counts['docker_tag'].to_i ||
           ostree_branches.count != pulp_counts['ostree'].to_i
@@ -142,7 +145,6 @@ module Katello
       def content_types
         [Katello.pulp_server.extensions.errata,
          Katello.pulp_server.extensions.package_group,
-         Katello.pulp_server.extensions.puppet_module,
          Katello.pulp_server.extensions.module_stream
         ]
       end
@@ -219,8 +221,6 @@ module Katello
         case content_type
         when Repository::YUM_TYPE
           "rpm"
-        when Repository::PUPPET_TYPE
-          "puppet_module"
         when Repository::DOCKER_TYPE
           "docker_manifest"
         when Repository::OSTREE_TYPE
@@ -242,10 +242,6 @@ module Katello
         self.content_type == Repository::DOCKER_TYPE
       end
 
-      def puppet?
-        self.content_type == Repository::PUPPET_TYPE
-      end
-
       def file?
         self.content_type == Repository::FILE_TYPE
       end
@@ -359,5 +355,19 @@ module Katello
         end
       end
     end
+
+    def full_path(smart_proxy = nil, force_http = false)
+      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : SETTINGS[:katello][:pulp][:url])
+      scheme = force_http ? 'http' : 'https'
+      if docker?
+        "#{pulp_uri.host.downcase}/#{container_repository_name}"
+      elsif ostree?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/web/#{relative_path}"
+      elsif ansible_collection?
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp_ansible/galaxy/#{relative_path}/api"
+      else
+        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/#{relative_path}/"
+      end
+    end
   end
 end

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

@@ -242,6 +242,7 @@ module Katello
         name 'Content Facet'
         refs 'ContentFacet'
         sections only: %w[all additional]
+        desc "Content facet is an object containing the host's content-related metadata and associations"
         property :id, Integer, desc: 'Returns ID of the facet'
         property :uuid, String, desc: 'Returns UUID of the facet'
         property :applicable_module_stream_count, Integer, desc: 'Returns applicable Module Stream count'

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

@@ -36,6 +36,8 @@ module Katello
       DMI_UUID_ALLOWED_DUPS = ['', 'Not Settable', 'Not Present'].freeze
       DMI_UUID_OVERRIDE_PARAM = 'dmi_uuid_override'.freeze
 
+      delegate :content_overrides, to: :candlepin_consumer, allow_nil: true
+
       def host_type
         host_facts = self.host.facts
         host_facts["virt::host_type"] || host_facts["hypervisor::type"]
@@ -225,7 +227,7 @@ module Katello
 
         name = rhsm_facts['distribution.name']
         version = rhsm_facts['distribution.version']
-        major, minor = version.split('.')
+        major, minor = version&.split('.')
         return host_os.name == 'CentOS' &&
           !host_os.major.nil? &&
           name == 'CentOS' &&

data/app/models/katello/kt_environment.rb

@@ -20,8 +20,6 @@ module Katello
     has_many :repositories, :class_name => "Katello::Repository", dependent: :destroy, foreign_key: :environment_id
     has_many :content_view_environments, :class_name => "Katello::ContentViewEnvironment",
                                          :foreign_key => :environment_id, :inverse_of => :environment, :dependent => :restrict_with_exception
-    has_many :content_view_puppet_environments, :class_name => "Katello::ContentViewPuppetEnvironment",
-                                                :foreign_key => :environment_id, :inverse_of => :environment, :dependent => :restrict_with_exception
     has_many :content_view_versions, :through => :content_view_environments, :inverse_of => :environments
     has_many :content_views, :through => :content_view_environments, :inverse_of => :environments
     has_many :content_view_histories, :class_name => "Katello::ContentViewHistory", :dependent => :destroy,
@@ -218,10 +216,6 @@ module Katello
       self.library? ? Product.in_org(self.organization) : Product.where(id: repositories.map(&:product_id))
     end
 
-    def puppet_repositories
-      self.repositories.readable.puppet_type
-    end
-
     def as_json(_options = {})
       to_ret = self.attributes
       to_ret['prior'] = self.prior && self.prior.name

data/app/models/katello/package_group.rb

@@ -29,5 +29,9 @@ module Katello
       group = service_class.new(self.pulp_id)
       group.default_package_names + group.conditional_package_names + group.optional_package_names + group.mandatory_package_names
     end
+
+    def content_view_filters
+      Katello::ContentViewPackageGroupFilterRule.where(uuid: self.pulp_id).eager_load(:filter).map(&:filter)
+    end
   end
 end

data/app/models/katello/ping.rb

@@ -5,10 +5,18 @@ module Katello
     PACKAGES = %w(katello candlepin pulp qpid foreman tfm hammer).freeze
 
     class << self
+      def pulpcore_enabled # for downstream 6.9, remove in 6.10
+        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]) ||
+        system('systemctl is-enabled pulpcore-api.service &>/dev/null')
+      end
+
       def services(capsule_id = nil)
         proxy = fetch_proxy(capsule_id)
         services = [:candlepin, :candlepin_auth, :foreman_tasks, :katello_events, :candlepin_events]
-        services += [:pulp3] if proxy&.pulp3_enabled?
+        services += [:pulp3] if proxy&.pulp3_enabled? && pulpcore_enabled
+        services += [:katello_agent] if ::Katello.with_katello_agent?
         if proxy.nil? || proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE) || proxy.has_feature?(SmartProxy::PULP_FEATURE)
           services += [:pulp, :pulp_auth]
         end
@@ -25,7 +33,7 @@ module Katello
 
         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(', ')}")
+          fail Katello::Errors::PingError, "The following services have not been started or are reporting errors: #{failed_names.join(', ')}"
         end
 
         result
@@ -65,7 +73,7 @@ module Katello
 
       def ping_katello_agent(result)
         exception_watch(result) do
-          status = Katello::EventDaemon::Runner.service_status(:katello_agent_events)
+          status = Katello::EventDaemon::Services::AgentEventReceiver.status(refresh: false)
           event_daemon_status(status, result)
         end
       end
@@ -215,7 +223,7 @@ module Katello
       private
 
       def failed_services(result)
-        result[:services].reject do |_name, details|
+        result[:services].select do |_name, details|
           details[:status] != OK_RETURN_CODE
         end
       end
@@ -248,9 +256,12 @@ module Katello
 
       def backend_status(url, backend)
         ca_file = SETTINGS[:katello][backend][:ca_cert_file]
+        request_id = ::Logging.mdc['request']
+
         options = {}
         options[:ssl_ca_file] = ca_file unless ca_file.nil?
         options[:verify_ssl] = SETTINGS[:katello][backend][:verify_ssl] if SETTINGS[:katello][backend].key?(:verify_ssl)
+        options[:headers] = { 'Correlation-ID' => request_id } if request_id
         client = RestClient::Resource.new("#{url}/status", options)
 
         response = client.get

data/app/models/katello/pool.rb

@@ -50,6 +50,15 @@ module Katello
 
     validates_lengths_from_database
 
+    validates :subscription, :presence => true
+    validates :organization, :presence => true
+
+    validate :subscription_matches_organization
+
+    def subscription_matches_organization
+      errors.add(:base, _("A Pool and its Subscription cannot belong to different organizations")) unless subscription&.organization_id == self.organization_id
+    end
+
     DAYS_RECENTLY_EXPIRED = 30
 
     def redhat?

data/app/models/katello/product.rb

@@ -226,12 +226,6 @@ module Katello
       result.length > 0 ? result.total : 0
     end
 
-    def total_puppet_module_count(env, view)
-      repo_ids = view.repos(env).in_product(self).collect { |r| r.pulp_id }
-      results = Katello::PuppetModule.legacy_search('', :page_size => 1, :repoids => repo_ids)
-      results.empty? ? 0 : results.total
-    end
-
     def self.humanize_class_name(_name = nil)
       _("Product and Repositories")
     end

data/app/models/katello/product_content.rb

@@ -16,8 +16,10 @@ module Katello
     }
 
     scoped_search :on => :name, :relation => :content
-    scoped_search :on => :content_type, :relation => :content
+    scoped_search :on => :content_type, :relation => :content, :complete_value => true
     scoped_search :on => :label, :relation => :content
+    scoped_search :on => :content_url, :relation => :content, :rename => :path
+    scoped_search :on => :enabled, :rename => :enabled_by_default, :complete_value => { :true => true, :false => false }
     scoped_search :on => :name, :relation => :product, :rename => :product_name
     scoped_search :on => :id, :relation => :product, :rename => :product_id, :only_explicit => true
     scoped_search :on => :label, :relation => :content, :rename => :content_label

data/app/models/katello/pulp_sync_status.rb

@@ -10,7 +10,6 @@ module Katello
         ht = HashUtil.new
 
         details = ht.null_safe_get(progress_attrs, nil, %w(progress_report yum_importer content)) ||
-                  ht.null_safe_get(progress_attrs, nil, %w(progress_report puppet_importer modules)) ||
                   ht.null_safe_get(progress_attrs, nil, %w(progress_report details packages sync_report)) ||
                   ht.null_safe_get(progress_attrs, nil, %w(progress_report iso_importer))
 
@@ -26,15 +25,6 @@ module Katello
         else
           @total_size  = ht.null_safe_get(details, 0, ['size_total'])
           @size_left   = ht.null_safe_get(details, 0, ['size_left'])
-
-          if progress_attrs['progress_report']['puppet_importer']
-            @total_count   = ht.null_safe_get(details, 0, ['total_count'])
-            finished_count = ht.null_safe_get(details, 0, ['finished_count'])
-            @items_left    = @total_count - finished_count
-          else
-            @total_count = ht.null_safe_get(details, 0, ['items_total'])
-            @items_left  = ht.null_safe_get(details, 0, ['items_left'])
-          end
         end
 
         @error_details = errors(progress_attrs['progress_report'])

data/app/models/katello/repository.rb

@@ -26,11 +26,12 @@ module Katello
     DEB_TYPE = 'deb'.freeze
     YUM_TYPE = 'yum'.freeze
     FILE_TYPE = 'file'.freeze
-    PUPPET_TYPE = 'puppet'.freeze
     DOCKER_TYPE = 'docker'.freeze
     OSTREE_TYPE = 'ostree'.freeze
     ANSIBLE_COLLECTION_TYPE = 'ansible_collection'.freeze
 
+    EXPORTABLE_TYPES = [YUM_TYPE, FILE_TYPE, ANSIBLE_COLLECTION_TYPE].freeze
+
     define_model_callbacks :sync, :only => :after
 
     belongs_to :root, :inverse_of => :repositories, :class_name => "Katello::RootRepository"
@@ -60,9 +61,6 @@ module Katello
     has_many :files, :through => :repository_file_units, :source => :file_unit
     alias_attribute :file_units, :files
 
-    has_many :repository_puppet_modules, :class_name => "Katello::RepositoryPuppetModule", :dependent => :delete_all
-    has_many :puppet_modules, :through => :repository_puppet_modules
-
     has_many :repository_docker_manifests, :class_name => "Katello::RepositoryDockerManifest", :dependent => :delete_all
     has_many :docker_manifests, :through => :repository_docker_manifests
 
@@ -129,17 +127,22 @@ module Katello
     scope :deb_type, -> { with_type(DEB_TYPE) }
     scope :yum_type, -> { with_type(YUM_TYPE) }
     scope :file_type, -> { with_type(FILE_TYPE) }
-    scope :puppet_type, -> { with_type(PUPPET_TYPE) }
     scope :docker_type, -> { with_type(DOCKER_TYPE) }
     scope :ostree_type, -> { with_type(OSTREE_TYPE) }
     scope :ansible_collection_type, -> { with_type(ANSIBLE_COLLECTION_TYPE) }
-    scope :non_puppet, -> { with_type(RepositoryTypeManager.repository_types.keys - [PUPPET_TYPE]) }
     scope :non_archived, -> { where('environment_id is not NULL') }
     scope :archived, -> { where('environment_id is NULL') }
     scope :in_published_environments, -> { in_content_views(Katello::ContentView.non_default).where.not(:environment_id => nil) }
     scope :order_by_root, ->(attr) { joins(:root).order("#{Katello::RootRepository.table_name}.#{attr}") }
     scope :with_content, ->(content) { joins(Katello::RepositoryTypeManager.find_content_type(content).model_class.repository_association_class.name.demodulize.underscore.pluralize.to_sym).distinct }
     scope :by_rpm_count, -> { left_joins(:repository_rpms).group(:id).order("count(katello_repository_rpms.id) ASC") } # smallest count first
+    scope :exportable, -> { with_type(EXPORTABLE_TYPES) }
+    scope :immediate_or_none, -> do
+      immediate.or(where("#{RootRepository.table_name}.download_policy" => nil)).
+        or(where("#{RootRepository.table_name}.download_policy" => ""))
+    end
+    scope :redhat, -> { joins(:product => :provider).where("#{Provider.table_name}.provider_type": Provider::REDHAT) }
+    scope :custom, -> { joins(:product => :provider).where.not("#{Provider.table_name}.provider_type": Provider::REDHAT) }
 
     scoped_search :on => :name, :relation => :root, :complete_value => true
     scoped_search :rename => :product, :on => :name, :relation => :product, :complete_value => true
@@ -163,15 +166,16 @@ module Katello
     scoped_search :on => :content_label, :ext_method => :search_by_content_label
 
     delegate :product, :redhat?, :custom?, :to => :root
-    delegate :yum?, :docker?, :puppet?, :deb?, :file?, :ostree?, :ansible_collection?, :to => :root
+    delegate :yum?, :docker?, :deb?, :file?, :ostree?, :ansible_collection?, :to => :root
     delegate :name, :label, :docker_upstream_name, :url, :download_concurrency, :to => :root
 
     delegate :name, :created_at, :updated_at, :major, :minor, :gpg_key_id, :gpg_key, :arch, :label, :url, :unprotected,
              :content_type, :product_id, :checksum_type, :docker_upstream_name, :mirror_on_sync, :"mirror_on_sync?",
              :download_policy, :verify_ssl_on_sync, :"verify_ssl_on_sync?", :upstream_username, :upstream_password,
              :ostree_upstream_sync_policy, :ostree_upstream_sync_depth, :deb_releases, :deb_components, :deb_architectures,
-             :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id, :ssl_client_key_id,
-             :ssl_client_key, :ignorable_content, :description, :docker_tags_whitelist, :ansible_collection_requirements, :http_proxy_policy, :http_proxy_id, :to => :root
+             :ssl_ca_cert_id, :ssl_ca_cert, :ssl_client_cert, :ssl_client_cert_id, :ssl_client_key_id, :os_versions,
+             :ssl_client_key, :ignorable_content, :description, :docker_tags_whitelist, :ansible_collection_requirements,
+             :ansible_collection_auth_url, :ansible_collection_auth_token, :http_proxy_policy, :http_proxy_id, :to => :root
 
     delegate :content_id, to: :root, allow_nil: true
 
@@ -395,20 +399,6 @@ module Katello
       all_instances
     end
 
-    def full_path(smart_proxy = nil, force_http = false)
-      pulp_uri = URI.parse(smart_proxy ? smart_proxy.url : ::SmartProxy.pulp_primary.url)
-      scheme = force_http ? 'http' : 'https'
-      if docker?
-        "#{pulp_uri.host.downcase}/#{container_repository_name}"
-      elsif ostree?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/web/#{relative_path}"
-      elsif ansible_collection?
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp_ansible/galaxy/#{relative_path}/api"
-      else
-        "#{scheme}://#{pulp_uri.host.downcase}/pulp/content/#{relative_path}/"
-      end
-    end
-
     def to_hash(content_source = nil, force_http = false)
       {id: id, name: label, url: full_path(content_source, force_http)}
     end
@@ -621,18 +611,6 @@ module Katello
       root.url.present?
     end
 
-    def name_conflicts
-      if puppet?
-        modules = PuppetModule.search("*", :repoids => self.pulp_id,
-                                           :fields => [:name],
-                                           :page_size => self.puppet_modules.count)
-
-        modules.map(&:name).group_by(&:to_s).select { |_, v| v.size > 1 }.keys
-      else
-        []
-      end
-    end
-
     def related_resources
       self.product
     end
@@ -955,6 +933,13 @@ module Katello
       DockerMetaTag.cleanup_tags
     end
 
+    apipie :class, desc: "A class representing #{model_name.human} object" do
+      name 'Repository'
+      refs 'Repository'
+      sections only: %w[all additional]
+      prop_group :katello_basic_props, Katello::Model, meta: { friendly_name: 'Repository' }
+      property :docker_upstream_name, String, desc: 'Returns name of the upstream docker repository'
+    end
     class Jail < ::Safemode::Jail
       allow :name, :label, :docker_upstream_name
     end

data/app/models/katello/root_repository.rb

@@ -99,7 +99,6 @@ module Katello
     scope :deb_type, -> { where(:content_type => Repository::DEB_TYPE) }
     scope :yum_type, -> { where(:content_type => Repository::YUM_TYPE) }
     scope :file_type, -> { where(:content_type => Repository::FILE_TYPE) }
-    scope :puppet_type, -> { where(:content_type => Repository::PUPPET_TYPE) }
     scope :docker_type, -> { where(:content_type => Repository::DOCKER_TYPE) }
     scope :ostree_type, -> { where(:content_type => Repository::OSTREE_TYPE) }
     scope :ansible_collection_type, -> { where(:content_type => Repository::ANSIBLE_COLLECTION_TYPE) }
@@ -273,10 +272,6 @@ module Katello
       self.content_type == Repository::DOCKER_TYPE
     end
 
-    def puppet?
-      self.content_type == Repository::PUPPET_TYPE
-    end
-
     def file?
       self.content_type == Repository::FILE_TYPE
     end

data/app/models/katello/subscription.rb

@@ -57,5 +57,15 @@ module Katello
     def self.humanize_class_name(_name = nil)
       _("Subscription")
     end
+
+    apipie :class, desc: "A class representing #{model_name.human} object" do
+      name 'Subscription'
+      refs 'Subscription'
+      sections only: %w[all additional]
+      prop_group :katello_idname_props, Katello::Model, meta: { friendly_name: 'Subscription' }
+    end
+    class Jail < ::Safemode::Jail
+      allow :id, :name
+    end
   end
 end

data/app/models/katello/sync_plan.rb

@@ -46,6 +46,13 @@ module Katello
       end
     end
 
+    def self.remove_disabled_product(repository)
+      if (product = repository.product) && product&.redhat? && (sync_plan = product&.sync_plan) && product&.repositories&.count == 1
+        sync_plan.product_ids = (sync_plan.product_ids - [product.id])
+        sync_plan.save!
+      end
+    end
+
     def product_enabled
       products.each do |product|
         errors.add :base, _("Can not add product %s because it is disabled.") % product.name unless product.enabled?

data/app/models/setting/content.rb

@@ -1,5 +1,4 @@
 class Setting::Content < Setting
-  #rubocop:disable Metrics/MethodLength
   #rubocop:disable Metrics/AbcSize
 
   validate :content_default_http_proxy, if: proc { |s| s.name == 'content_default_http_proxy' && HttpProxy.table_exists? }
@@ -111,7 +110,9 @@ class Setting::Content < Setting
                "/etc/pki/katello/private/pulp-client.key", N_('Pulp client key')),
       self.set('pulp_client_cert', N_("Path for ssl cert used for pulp server auth"),
                "/etc/pki/katello/certs/pulp-client.crt", N_('Pulp client cert')),
-      self.set('remote_execution_by_default', N_("If set to true, use the remote execution over katello-agent for remote actions"),
+      self.set('sync_connect_timeout', N_("Total timeout in seconds for connections when syncing"),
+               300, N_('Sync Connection Timeout')),
+      self.set('remote_execution_by_default', N_("If set to true, use remote execution instead of katello-agent for remote actions"),
                false, N_('Use remote execution by default')),
       self.set('unregister_delete_host', N_("When unregistering a host via subscription-manager, also delete the host record. Managed resources linked to host " \
                                             "such as virtual machines and DNS records may also be deleted."),
@@ -124,10 +125,6 @@ class Setting::Content < Setting
                N_('Default Location where new subscribed hosts will put upon registration'),
                nil, N_('Default Location subscribed hosts'), nil,
                :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
-      self.set('default_location_puppet_content',
-               N_('Default Location where new Puppet content will be put upon Content View publish'),
-               nil, N_('Default Location Puppet content'), nil,
-               :collection => proc { Hash[Location.unscoped.all.map { |loc| [loc[:title], loc[:title]] }] }),
       self.set('expire_soon_days', N_('The number of days remaining in a subscription before you will be reminded about renewing it.'),
                120, N_('Expire soon days')),
       self.set('content_view_solve_dependencies',
@@ -153,13 +150,15 @@ class Setting::Content < Setting
       self.set('autosearch_while_typing', N_('For pages that support it, automatically perform search while typing in search input.'),
                true, N_('Autosearch')),
       self.set('autosearch_delay', N_('If Autosearch is enabled, delay in milliseconds before executing searches while typing.'),
-               500, N_('Autosearch delay'))
+               500, N_('Autosearch delay')),
+      self.set('bulk_load_size', N_('The number of items fetched from a single paged Pulp API call.'), 2000,
+               N_('Pulp bulk load size'))
     ]
   end
 
   def self.load_defaults
     BLANK_ATTRS.concat %w(register_hostname_fact default_location_subscribed_hosts
-                          default_location_puppet_content content_default_http_proxy host_dmi_uuid_duplicates cdn_ssl_version)
+                          content_default_http_proxy host_dmi_uuid_duplicates cdn_ssl_version)
     super
   end
 

data/app/presenters/katello/content_view_version_compare_presenter.rb

@@ -7,12 +7,8 @@ module Katello
     end
 
     def comparison
-      if @item.is_a?(::Katello::PuppetModule)
-        item_repos = @item.content_view_puppet_environments
-      else
-        item_repos = @item.repositories
-        item_repos.where(:library_instance_id => @repository.id) if @repository
-      end
+      item_repos = @item.repositories
+      item_repos.where(:library_instance_id => @repository.id) if @repository
 
       item_repos.map(&:content_view_version_id) & @versions.map(&:id)
     end

data/app/presenters/katello/product_content_presenter.rb

@@ -9,21 +9,19 @@ module Katello
     end
 
     def override
+      return 'default' if overrides.blank?
       override = overrides.find { |pc| pc.content_label == content.label && pc.name == "enabled" }
       override.nil? ? 'default' : override.value
     end
 
     def enabled_content_override
+      return nil if overrides.blank?
       overrides.find { |pc| pc.content_label == content.label && pc.name == "enabled" }
     end
 
     def content_overrides
+      return [] if overrides.blank?
       overrides.select { |pc| pc.content_label == content.label }
     end
-
-    def legacy_content_override
-      override = @overrides.find { |pc| pc.content_label == content.label && pc.name == "enabled" }
-      override.nil? ? 'default' : override.value
-    end
   end
 end

data/app/services/cert/certs.rb

@@ -5,15 +5,11 @@ module Cert
     end
 
     def self.ca_cert
-      File.open(Setting[:ssl_ca_file], 'r').read
-    end
-
-    def self.candlepin_client_ca_cert
-      File.read(SETTINGS[:katello][:candlepin][:ca_cert_file])
+      File.read(Setting[:ssl_ca_file])
     end
 
     def self.ssl_client_cert
-      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.open(ssl_client_cert_filename, 'r').read)
+      @ssl_client_cert ||= OpenSSL::X509::Certificate.new(File.read(ssl_client_cert_filename))
     end
 
     def self.ssl_client_cert_filename
@@ -21,7 +17,7 @@ module Cert
     end
 
     def self.ssl_client_key
-      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.open(ssl_client_key_filename, 'r').read)
+      @ssl_client_key ||= OpenSSL::PKey::RSA.new(File.read(ssl_client_key_filename))
     end
 
     def self.ssl_client_key_filename

data/app/services/katello/applicability/applicable_content_helper.rb

@@ -92,8 +92,7 @@ module Katello
         ::Katello::ModuleStream.
           joins("inner join katello_available_module_streams on
             katello_module_streams.name = katello_available_module_streams.name and
-            katello_module_streams.stream = katello_available_module_streams.stream and
-            katello_module_streams.context = katello_available_module_streams.context").
+            katello_module_streams.stream = katello_available_module_streams.stream").
           joins("inner join katello_host_available_module_streams on
             katello_available_module_streams.id = katello_host_available_module_streams.available_module_stream_id").
           where("katello_host_available_module_streams.host_id = :content_facet_id and

data/app/services/katello/candlepin/event_handler.rb

@@ -8,30 +8,30 @@ module Katello
       end
 
       def handle(message)
-        @logger.debug("message received from subscriptions queue ")
-        @logger.debug("message subject: #{message.subject}")
-
         ::User.current = ::User.anonymous_admin
 
-        @message_handler = ::Katello::Candlepin::MessageHandler.new(message)
-
-        case message_handler.subject
-        when /entitlement\.created/
-          message_handler.import_pool
-          message_handler.create_pool_on_host
-        when /entitlement\.deleted/
-          message_handler.import_pool
-          message_handler.remove_pool_from_host
-        when /pool\.created/
-          message_handler.import_pool
-        when /pool\.deleted/
-          message_handler.delete_pool
-        when /^compliance\.created/
-          reindex_subscription_status
-        when /system_purpose_compliance\.created/
-          reindex_purpose_status
-        when /owner_content_access_mode\.modified/
-          message_handler.handle_content_access_mode_modified
+        Katello::Logging.time("candlepin event handled", logger: @logger) do |data|
+          data[:subject] = message.subject
+          @message_handler = ::Katello::Candlepin::MessageHandler.new(message)
+          data[:entity_id] = @message_handler.entity_id
+          case message_handler.subject
+          when /entitlement\.created/
+            message_handler.import_pool
+            message_handler.create_pool_on_host
+          when /entitlement\.deleted/
+            message_handler.import_pool
+            message_handler.remove_pool_from_host
+          when /pool\.created/
+            message_handler.import_pool
+          when /pool\.deleted/
+            message_handler.delete_pool
+          when /^compliance\.created/
+            reindex_subscription_status
+          when /system_purpose_compliance\.created/
+            reindex_purpose_status
+          when /owner_content_access_mode\.modified/
+            message_handler.handle_content_access_mode_modified
+          end
         end
       end