katello 3.5.2 → 3.6.0.rc1

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

@@ -24,6 +24,10 @@ module Katello
         repository_association_class.name.demodulize.pluralize.underscore
       end
 
+      def immutable_unit_types
+        [Katello::Rpm, Katello::Srpm]
+      end
+
       def with_identifiers(ids)
         ids = [ids] unless ids.is_a?(Array)
         ids.map!(&:to_s)
@@ -72,21 +76,38 @@ module Katello
         # Rpms cannot change in Pulp so we do not index them if they are already present
         # in our database. Errata and Package Groups can change in Pulp, so we index
         # all of them in the repository on each sync.
-        if self == Katello::Rpm && !force
+        if immutable_unit_types.include?(self) && !force
           ids_to_import = ids - repository.rpms.map(&:uuid)
         else
           ids_to_import = ids
         end
         self.import_all(ids_to_import, :index_repository_association => false) if repository.content_view.default? || force
-        self.sync_repository_associations(repository, ids) if self.manage_repository_association
+        self.sync_repository_associations(repository, :uuids => ids) if self.manage_repository_association
       end
 
       def unit_id_field
         "#{self.name.demodulize.underscore}_id"
       end
 
-      def sync_repository_associations(repository, unit_uuids, additive = false)
-        associated_ids = with_uuid(unit_uuids).pluck(:id)
+      def copy_repository_associations(source_repo, dest_repo)
+        delete_query = "delete from #{repository_association_class.table_name} where repository_id = #{dest_repo.id} and
+                       #{unit_id_field} not in (select #{unit_id_field} from #{repository_association_class.table_name} where repository_id = #{source_repo.id})"
+        ActiveRecord::Base.connection.execute(delete_query)
+
+        insert_query = "insert into #{repository_association_class.table_name} (repository_id, #{unit_id_field})
+                        select #{dest_repo.id} as repository_id, #{unit_id_field} from #{repository_association_class.table_name}
+                        where repository_id = #{source_repo.id} and #{unit_id_field} not in (select #{unit_id_field}
+                        from #{repository_association_class.table_name} where repository_id = #{dest_repo.id})"
+        ActiveRecord::Base.connection.execute(insert_query)
+      end
+
+      def sync_repository_associations(repository, options = {})
+        additive = options.fetch(:additive, false)
+        associated_ids = options.fetch(:ids, nil)
+        uuids = options.fetch(:uuids) if associated_ids.nil?
+
+        associated_ids = with_uuid(uuids).pluck(:id) if uuids
+
         table_name = self.repository_association_class.table_name
         attribute_name = unit_id_field
 
@@ -132,7 +153,7 @@ module Katello
           end
 
           repo_unit_id.each do |repo_pulp_id, unit_uuids|
-            sync_repository_associations(Repository.find_by(:pulp_id => repo_pulp_id), unit_uuids, additive)
+            sync_repository_associations(Repository.find_by(:pulp_id => repo_pulp_id), :uuids => unit_uuids, :additive => additive)
           end
         end
       end

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

@@ -3,9 +3,29 @@ module Katello
     module RedhatExtensions
       extend ActiveSupport::Concern
 
+      module Overrides
+        def medium_uri(host, url = nil)
+          kickstart_repo = host.try(:content_facet).try(:kickstart_repository) || host.try(:kickstart_repository)
+
+          if host.try(:content_source) && kickstart_repo.present?
+            return URI.parse(kickstart_repo.full_path(host.content_source))
+          else
+            super(host, url)
+          end
+        end
+
+        # overwrite foreman method in operatingsystem.rb
+        def boot_files_uri(medium, architecture, host = nil)
+          return super(medium, architecture, host) unless host.try(:content_source)
+          family_class = self.family.constantize
+          family_class::PXEFILES.values.collect do |img|
+            "#{medium_uri(host)}/#{pxedir}/#{img}"
+          end
+        end
+      end
+
       included do
-        alias_method_chain :medium_uri, :content_uri
-        alias_method_chain :boot_files_uri, :content
+        prepend Overrides
       end
 
       module ClassMethods
@@ -45,16 +65,6 @@ module Katello
         end
       end
 
-      def medium_uri_with_content_uri(host, url = nil)
-        kickstart_repo = host.try(:content_facet).try(:kickstart_repository) || host.try(:kickstart_repository)
-
-        if host.try(:content_source) && kickstart_repo.present?
-          return URI.parse(kickstart_repo.full_path(host.content_source))
-        else
-          medium_uri_without_content_uri(host, url)
-        end
-      end
-
       def kickstart_repos(host)
         distros = distribution_repositories(host)
         if distros && host.content_source
@@ -79,15 +89,6 @@ module Katello
           []
         end
       end
-
-      # overwrite foreman method in operatingsystem.rb
-      def boot_files_uri_with_content(medium, architecture, host = nil)
-        return boot_files_uri_without_content(medium, architecture, host) unless host.try(:content_source)
-        family_class = self.family.constantize
-        family_class::PXEFILES.values.collect do |img|
-          "#{medium_uri(host)}/#{pxedir}/#{img}"
-        end
-      end
     end
   end
 end

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

@@ -6,6 +6,14 @@ module Katello
     module SmartProxyExtensions
       extend ActiveSupport::Concern
 
+      module Overrides
+        def refresh
+          errors = super
+          update_puppet_path
+          errors
+        end
+      end
+
       PULP_FEATURE = "Pulp".freeze
       PULP_NODE_FEATURE = "Pulp Node".freeze
 
@@ -16,7 +24,7 @@ module Katello
         include ForemanTasks::Concerns::ActionSubject
         include LazyAccessor
 
-        alias_method_chain :refresh, :puppet_path
+        prepend Overrides
 
         before_create :associate_organizations
         before_create :associate_default_locations
@@ -43,10 +51,10 @@ module Katello
                  :source     => :lifecycle_environment
 
         has_many :content_facets, :class_name => "::Katello::Host::ContentFacet", :foreign_key => :content_source_id,
-                                  :inverse_of => :content_source
+                                  :inverse_of => :content_source, :dependent => :nullify
 
         has_many :hostgroups, :class_name => "::Hostgroup", :foreign_key => :content_source_id,
-                              :inverse_of => :content_source
+                              :inverse_of => :content_source, :dependent => :nullify
 
         validates :download_policy, inclusion: {
           :in => DOWNLOAD_POLICIES,
@@ -79,12 +87,6 @@ module Katello
         path
       end
 
-      def refresh_with_puppet_path
-        errors = refresh_without_puppet_path
-        update_puppet_path
-        errors
-      end
-
       def pulp_node
         @pulp_node ||= Katello::Pulp::Server.config(pulp_url, User.remote_user)
       end

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

@@ -2,7 +2,6 @@ module Katello
   module Concerns
     module SubscriptionFacetHostExtensions
       extend ActiveSupport::Concern
-      include ForemanTasks::Concerns::ActionTriggering
 
       included do
         SUBSCRIPTION_STATUS_MAP = {
@@ -13,24 +12,26 @@ module Katello
           :unsubscribed_hypervisor => Katello::SubscriptionStatus::UNSUBSCRIBED_HYPERVISOR
         }.freeze
 
+        prepend ForemanTasks::Concerns::ActionTriggering
+
         accepts_nested_attributes_for :subscription_facet, :update_only => true, :reject_if => lambda { |attrs| attrs.values.compact.empty? }
 
         has_many :activation_keys, :through => :subscription_facet
         has_many :pools, :through => :subscription_facet
         has_many :subscriptions, :through => :pools
-        has_one :subscription_status_object, :class_name => 'Katello::SubscriptionStatus', :foreign_key => 'host_id'
+        has_one :subscription_status_object, :class_name => 'Katello::SubscriptionStatus', :foreign_key => 'host_id', :dependent => :destroy
         has_one :hypervisor_host, :through => :subscription_facet
 
         scoped_search :on => :status, :relation => :subscription_status_object, :rename => :subscription_status,
                       :complete_value => SUBSCRIPTION_STATUS_MAP
 
-        scoped_search :on => :release_version, :relation => :subscription_facet, :complete_value => true
-        scoped_search :on => :autoheal, :relation => :subscription_facet, :complete_value => true
-        scoped_search :on => :service_level, :relation => :subscription_facet, :complete_value => true
+        scoped_search :on => :release_version, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
+        scoped_search :on => :autoheal, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
+        scoped_search :on => :service_level, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :last_checkin, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
-        scoped_search :on => :registered_through, :relation => :subscription_facet, :complete_value => true
+        scoped_search :on => :registered_through, :relation => :subscription_facet, :complete_value => true, :only_explicit => true
         scoped_search :on => :registered_at, :relation => :subscription_facet, :rename => :registered_at, :only_explicit => true
-        scoped_search :on => :uuid, :relation => :subscription_facet, :rename => :subscription_uuid
+        scoped_search :on => :uuid, :relation => :subscription_facet, :rename => :subscription_uuid, :only_explicit => true
         scoped_search :relation => :activation_keys, :on => :name, :rename => :activation_key, :complete_value => true, :ext_method => :find_by_activation_key
         scoped_search :relation => :activation_keys, :on => :id, :rename => :activation_key_id, :complete_value => true, :ext_method => :find_by_activation_key_id,
                       :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER

data/app/models/katello/content.rb

@@ -0,0 +1,26 @@
+module Katello
+  class Content < Katello::Model
+    include Katello::Glue::Candlepin::Content
+    has_many :product_contents, :class_name => 'Katello::ProductContent', :dependent => :destroy
+    has_many :products, :through => :product_contents
+
+    validates :label, :uniqueness => true
+    validates :cp_content_id, :uniqueness => true
+
+    def self.import_all
+      Organization.all.each do |org|
+        org.products.each do |product|
+          begin
+            product_json = Katello::Resources::Candlepin::Product.get(org.label,
+                                                                  product.cp_id,
+                                                                  %w(productContent)).first
+            product_content_attrs = product_json['productContent']
+            Katello::Glue::Candlepin::Product.import_product_content(product, product_content_attrs)
+          rescue RestClient::NotFound
+            Rails.logger.warn _("Product with ID %s not found in Candlepin. Skipping content import for it.") % product.cp_id
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/katello/content_view.rb

@@ -65,6 +65,7 @@ module Katello
 
     scoped_search :on => :name, :complete_value => true
     scoped_search :on => :organization_id, :complete_value => true, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
+    scoped_search :on => :label, :complete_value => true
     scoped_search :on => :composite, :complete_value => {true: true, false: false}
 
     def self.in_environment(env)
@@ -168,7 +169,7 @@ module Katello
 
     def promoted?
       # if the view exists in more than 1 environment, it has been promoted
-      self.environments.length > 1 ? true : false
+      self.environments.many?
     end
 
     #NOTE: this function will most likely become obsolete once we drop api v1
@@ -196,6 +197,10 @@ module Katello
       Katello::Rpm.in_repositories(self.repos(env)).count
     end
 
+    def total_deb_package_count(env)
+      Katello::Deb.in_repositories(self.repos(env)).count
+    end
+
     def total_puppet_module_count(env)
       repoids = self.repos(env).collect { |r| r.pulp_id }
       result = Katello::PuppetModule.legacy_search('*', :page_size => 1, :repoids => repoids)
@@ -287,12 +292,20 @@ module Katello
       # is the library instance id, and the value is an array
       # of the repositories for that instance.
       repositories_to_publish.inject({}) do |result, repo|
-        result[repo.library_instance_id] ||= []
-        result[repo.library_instance_id] << repo
+        result[repo.library_instance] ||= []
+        result[repo.library_instance] << repo
         result
       end
     end
 
+    def duplicate_repositories_to_publish
+      repositories_to_publish_by_library_instance.select { |_key, val| val.count > 1 }.keys
+    end
+
+    def components_with_repo(library_instance)
+      components.select { |component| component.repositories.where(:library_instance => library_instance).any? }
+    end
+
     def publish_repositories
       repositories = composite? ? repositories_to_publish_by_library_instance.values : repositories_to_publish
       repositories.each do |repos|
@@ -510,7 +523,7 @@ module Katello
         end
       end
 
-      puppet_modules = PuppetModule.where(:uuid => uuids) if uuids.present?
+      puppet_modules = PuppetModule.where(:uuid => uuids).to_a if uuids.present?
 
       if names_and_authors.present?
         names_and_authors.each do |name_and_author|
@@ -524,7 +537,7 @@ module Katello
       end
 
       # In order to minimize the number of copy requests, organize the data by repoid.
-      PuppetModule.group_by_repoid(puppet_modules)
+      PuppetModule.group_by_repoid(puppet_modules.flatten)
     end
 
     def check_ready_to_publish!

data/app/models/katello/content_view_component.rb

@@ -62,7 +62,7 @@ module Katello
 
     def attached_content_view_ids
       composite_content_view.content_view_components.map do |cvc|
-        next if cvc.id == self.id
+        next if cvc == self
         if cvc.content_view_version
           cvc.content_view_version.content_view_id
         else

data/app/models/katello/content_view_docker_filter.rb

@@ -18,20 +18,29 @@ module Katello
         manifest_tags.concat(query_manifests(repo, rule))
       end
 
-      { "name" => { "$in" => manifest_tags } } unless manifest_tags.empty?
+      { "_id" => { "$in" => manifest_tags } } unless manifest_tags.empty?
     end
 
     protected
 
-    def query_manifests(repo, rule)
+    def fetch_tag_uuids(repo, rule, manifest_klass = DockerManifest)
       query_name = rule.name.tr("*", "%")
-      query = DockerManifest.joins(:docker_tags).in_repositories(repo).where("#{DockerTag.table_name}.name ilike ?", query_name).uniq
+      tags_query = ::Katello::DockerTag.where(:repository => repo).
+                                        where(:docker_taggable_type => manifest_klass.name).
+                                        where("name ilike ?", query_name).
+                                        select(:docker_taggable_id)
+
+      query = manifest_klass.in_repositories(repo).where("id in (#{tags_query.to_sql})")
       names = query.all.collect do |manifest|
-        manifest.docker_tags.all.collect do |tag|
-          tag.name
+        manifest.docker_tags.where(:repository => repo).all.collect do |tag|
+          tag.uuid
         end
       end
-      names.flatten
+      names.flatten.uniq
+    end
+
+    def query_manifests(repo, rule)
+      (fetch_tag_uuids(repo, rule, DockerManifest) + fetch_tag_uuids(repo, rule, DockerManifestList)).flatten.uniq
     end
   end
 end

data/app/models/katello/content_view_filter.rb

@@ -4,8 +4,9 @@ module Katello
     RPM = Rpm::CONTENT_TYPE
     PACKAGE_GROUP   = PackageGroup::CONTENT_TYPE
     ERRATA          = Erratum::CONTENT_TYPE
-    CONTENT_TYPES   = [RPM, PACKAGE_GROUP, ERRATA, DOCKER].freeze
-    CONTENT_OPTIONS = { _('Packages') => RPM, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Docker') => DOCKER }.freeze
+    DEB             = Deb::CONTENT_TYPE
+    CONTENT_TYPES   = [RPM, PACKAGE_GROUP, ERRATA, DOCKER, DEB].freeze
+    CONTENT_OPTIONS = { _('Packages') => RPM, _('Package Groups') => PACKAGE_GROUP, _('Errata') => ERRATA, _('Docker') => DOCKER, _('deb Packages') => DEB }.freeze
 
     belongs_to :content_view,
                :class_name => "Katello::ContentView",
@@ -42,6 +43,11 @@ module Katello
                       ::Katello::ContentViewPackageFilter.name])
     end
 
+    def self.deb
+      # TODO
+      []
+    end
+
     def self.docker
       where(:type => [::Katello::ContentViewDockerFilter.name])
     end

data/app/models/katello/content_view_puppet_environment.rb

@@ -42,6 +42,14 @@ module Katello
       true
     end
 
+    def link?
+      false
+    end
+
+    def master
+      true
+    end
+
     def node_syncable?
       environment
     end
@@ -88,6 +96,10 @@ module Katello
       end
     end
 
+    def ignore_global_proxy
+      false
+    end
+
     def set_pulp_id
       if self.environment
         label = "#{self.content_view.label}-#{self.environment.label}-puppet-#{SecureRandom.uuid}"

data/app/models/katello/content_view_repository.rb

@@ -3,7 +3,8 @@ module Katello
     ALLOWED_REPOSITORY_TYPES = [Repository::YUM_TYPE,
                                 Repository::DOCKER_TYPE,
                                 Repository::OSTREE_TYPE,
-                                Repository::FILE_TYPE
+                                Repository::FILE_TYPE,
+                                Repository::DEB_TYPE
                                ].freeze
 
     belongs_to :content_view, :inverse_of => :content_view_repositories,

data/app/models/katello/content_view_version.rb

@@ -115,6 +115,10 @@ module Katello
       composite_content_views.any?
     end
 
+    def published_in_composite?
+      content_view_version_composites.any?
+    end
+
     def in_environment?
       environments.any?
     end
@@ -151,6 +155,10 @@ module Katello
       self.repositories.non_archived
     end
 
+    def library_repos
+      archived_repos.includes(:library_instance).map(&:library_instance)
+    end
+
     def products(env = nil)
       if env
         repos(env).map(&:product).uniq(&:id)
@@ -218,7 +226,11 @@ module Katello
     end
 
     def packages
-      Rpm.in_repositories(archived_repos).uniq
+      Rpm.in_repositories(archived_repos)
+    end
+
+    def srpm_count
+      Katello::Srpm.in_repositories(self.repositories.archived).count
     end
 
     def puppet_module_count
@@ -237,40 +249,62 @@ module Katello
       ostree_branches.count
     end
 
-    def docker_manifest_count
-      manifest_counts = repositories.archived.docker_type.map do |repo|
-        repo.docker_manifests.count
+    def docker_manifest_list_count
+      repositories.archived.docker_type.inject(0) do |sum, repo|
+        sum + repo.docker_manifest_lists.count
       end
-      manifest_counts.sum
     end
 
-    def docker_tags
-      archived_repos.docker_type.flat_map(&:docker_tags)
+    def docker_manifest_count
+      repositories.archived.docker_type.inject(0) do |sum, repo|
+        sum + repo.docker_manifests.count
+      end
     end
 
     def docker_tag_count
-      tag_counts = repositories.archived.docker_type.map do |repo|
-        repo.docker_tags.count
-      end
-      tag_counts.sum
+      ::Katello::DockerMetaTag.where(:repository_id => repositories.archived.docker_type).count
+    end
+
+    def debs
+      Katello::Deb.in_repositories(self.repositories.archived)
+    end
+
+    def deb_count
+      debs.count
     end
 
     def errata(errata_type = nil)
-      errata = Erratum.in_repositories(archived_repos).uniq
+      errata = Erratum.in_repositories(archived_repos)
       errata = errata.of_type(errata_type) if errata_type
       errata
     end
 
+    def library_errata
+      Erratum.in_repositories(library_repos)
+    end
+
+    def available_errata
+      library_errata.where.not(:id => errata)
+    end
+
+    def file_units
+      FileUnit.in_repositories(archived_repos)
+    end
+
     def ostree_branches
-      OstreeBranch.in_repositories(archived_repos).uniq
+      OstreeBranch.in_repositories(archived_repos)
     end
 
     def docker_manifests
-      DockerManifest.in_repositories(archived_repos).uniq
+      DockerManifest.in_repositories(archived_repos)
+    end
+
+    def docker_manifest_lists
+      DockerManifestList.in_repositories(archived_repos)
     end
 
     def package_groups
-      PackageGroup.in_repositories(archived_repos).uniq
+      PackageGroup.in_repositories(archived_repos)
     end
 
     def package_group_count
@@ -293,6 +327,14 @@ module Katello
           fail _("Cannot delete version while it is in use by composite content views: %s") %
                    composite_content_views.map(&:name).join(",")
         end
+
+        if published_in_composite?
+          list = composites.map do |version|
+            "#{version.content_view.name} Version #{version.version}"
+          end
+          fail _("Cannot delete version while it is in use by composite content views: %s") %
+                   list.join(",")
+        end
       end
       true
     end