katello 3.3.0.rc1.1 → 3.3.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 27da4eecf491c4840dd61deabbd4b3bb50b73966
-  data.tar.gz: 45131f798de1ce8b61ef5edf8c0925a3696e90d0
+  metadata.gz: 8e71d2d24ee870d0c10c9aef24333f76d6ba6cd9
+  data.tar.gz: fb29c9754551fe3fe1cb49e989dabdb47d732f74
 SHA512:
-  metadata.gz: 9e4bb933214d3fbb655d65c60edb485b3f719663381dfaddeba4f6d955ffa96379f0ee185c343c64f20da59b57739da5f502e7f5e2c6dbd989485b0321a932b7
-  data.tar.gz: d0da59d96c218cc220d828ad70593ae9a6477d06ab6b33229c8301d71b51f652a40d0716f0711494d9e8c2ea1ef10cdffce9cd7994314f45b5b12d9ab9cfac2e
+  metadata.gz: c9b4d0575247f45221ae2d38ff05921af5e0d7cf0b0b20802d2c05b0f9e365353f0d7309e45586f4f8079cd17b86bb8c100ec6afe7a7de74b82a90cac5162781
+  data.tar.gz: c79a34dada9c793960804035c96a4c5f4a01376ef483476eae0edad7d9813f008818c1bcae68e66fd1681e9ece01b205bbe5d9604d83dab65c1fedf7443d1754

data/app/controllers/katello/api/v2/content_view_filter_rules_controller.rb

@@ -19,7 +19,7 @@ module Katello
     api :POST, "/content_view_filters/:content_view_filter_id/rules",
         N_("Create a filter rule. The parameters included should be based upon the filter type.")
     param :content_view_filter_id, :identifier, :desc => N_("filter identifier"), :required => true
-    param :name, [String, Array], :desc => N_("package and package group names")
+    param :name, [String, Array], :desc => N_("package, package group, or docker tag names")
     param :version, String, :desc => N_("package: version")
     param :arch, String, :desc => N_("package: architecture")
     param :min_version, String, :desc => N_("package: minimum version")
@@ -64,7 +64,7 @@ module Katello
         N_("Update a filter rule. The parameters included should be based upon the filter type.")
     param :content_view_filter_id, :identifier, :desc => N_("filter identifier"), :required => true
     param :id, :identifier, :desc => N_("rule identifier"), :required => true
-    param :name, String, :desc => N_("package or package group: name")
+    param :name, String, :desc => N_("package, package group, or docker tag: name")
     param :version, String, :desc => N_("package: version")
     param :min_version, String, :desc => N_("package: minimum version")
     param :max_version, String, :desc => N_("package: maximum version")

data/app/controllers/katello/api/v2/content_view_filters_controller.rb

@@ -12,6 +12,7 @@ module Katello
     param_group :search, Api::V2::ApiController
     param :content_view_id, :identifier, :desc => N_("content view identifier"), :required => true
     param :name, String, :desc => N_("filter content view filters by name")
+    param :types, Array, :desc => N_("types of filters")
     def index
       respond(:collection => scoped_search(index_relation.uniq, :name, :asc))
     end
@@ -19,6 +20,12 @@ module Katello
     def index_relation
       query = ContentViewFilter.where(:content_view_id => (@view || ContentView.readable))
       query = query.where(:name => params[:name]) if params[:name]
+      if params[:types]
+        types = params[:types].each.collect do |type|
+          ::Katello::ContentViewFilter.class_for(type)
+        end
+        query = query.where("#{::Katello::ContentViewFilter.table_name}.type IN (?)", types)
+      end
       query
     end
 
@@ -26,7 +33,7 @@ module Katello
     api :post, "/content_view_filters", N_("create a filter for a content view")
     param :content_view_id, :identifier, :desc => N_("content view identifier"), :required => true
     param :name, String, :desc => N_("name of the filter"), :required => true
-    param :type, String, :desc => N_("type of filter (e.g. rpm, package_group, erratum)"), :required => true
+    param :type, String, :desc => N_("type of filter (e.g. rpm, package_group, erratum, docker)"), :required => true
     param :original_packages, :bool, :desc => N_("add all packages without errata to the included/excluded list. " \
                                                        "(package filter only)")
     param :inclusion, :bool, :desc => N_("specifies if content should be included or excluded, default: inclusion=false")

data/app/controllers/katello/api/v2/content_views_controller.rb

@@ -92,17 +92,28 @@ module Katello
     param :id, :identifier, :desc => N_("content view numeric identifier"), :required => true
     param :name, String, :desc => N_("module name to restrict modules for"), :required => false
     def available_puppet_modules
-      current_uuids = @view.content_view_puppet_modules.where("uuid is NOT NULL").pluck(:uuid)
+      current_cv_puppet_modules = @view.content_view_puppet_modules.where("uuid is NOT NULL")
+      current_uuids = current_cv_puppet_modules.pluck(:uuid)
       repositories = @view.organization.library.puppet_repositories
-
       query = PuppetModule.in_repositories(repositories)
-      query = query.where(:name => params[:name]) if params[:name]
+      selected_latest_versions = []
+      if params[:name]
+        query = query.where(:name => params[:name])
+        if current_uuids.present?
+          module_by_name = current_cv_puppet_modules.find_by(:name => params[:name])
+          if module_by_name && module_by_name.latest_in_modules_by_author?(query)
+            current_uuids.delete(module_by_name.uuid)
+            selected_latest_versions.push(module_by_name.uuid)
+          end
+        end
+      end
       query = query.where("#{PuppetModule.table_name}.uuid NOT in (?)", current_uuids) if current_uuids.present?
       custom_sort = ->(sort_query) { sort_query.order('author, name, sortable_version DESC') }
-
-      respond_for_index :template => 'puppet_modules',
-                        :collection => scoped_search(query, nil, nil, :resource_class => PuppetModule,
-                                                     :custom_sort => custom_sort)
+      sorted_records = scoped_search(query, nil, nil, :resource_class => PuppetModule, :custom_sort => custom_sort)
+      if params[:name]
+        sorted_records[:results] = add_use_latest_records(sorted_records[:results].to_a, selected_latest_versions)
+      end
+      respond_for_index :template => 'puppet_modules', :collection => sorted_records
     end
 
     api :GET, "/content_views/:id/available_puppet_module_names",
@@ -200,5 +211,17 @@ module Katello
       return if !params.key?(:environment_id) && params[:action] == "index"
       @environment = KTEnvironment.find(params[:environment_id])
     end
+
+    def add_use_latest_records(module_records, selected_latest_versions)
+      module_records.group_by(&:author).each_pair do |_author, records|
+        top_rec = records[0]
+        latest = top_rec.dup
+        latest.version = _("Always Use Latest (currently %{version})") % { version: latest.version }
+        latest.uuid = nil
+        module_records.delete(top_rec) if selected_latest_versions.include?(top_rec.uuid)
+        module_records.push(latest)
+      end
+      module_records
+    end
   end
 end

data/app/controllers/katello/api/v2/host_contents_controller.rb

@@ -3,6 +3,7 @@ module Katello
     def_param_group :content_facet_attributes do
       param :content_view_id, Integer
       param :lifecycle_environment_id, Integer
+      param :content_source_id, Integer
       param :kickstart_repository_id, Integer, :desc => N_("Repository Id associated with the kickstart repo used for provisioning")
     end
   end

data/app/controllers/katello/products_controller.rb

@@ -17,15 +17,14 @@ module Katello
         render_bad_parameters _('Repository sets are not available for custom products.')
       else
         task = sync_task(::Actions::Katello::RepositorySet::ScanCdn, @product, params[:content_id])
-        if task.result == 'warning'
-          render :partial => 'katello/providers/redhat/errors', :locals => { :error_message => task_error(task), :task => task}
-        else
-          repos = task.output[:results]
-          repos = exclude_rolling_kickstart_repos(repos)
-          repos = available_synced_repos(repos) if params[:orphaned]
 
-          render :partial => 'katello/providers/redhat/repos', :locals => {:scan_cdn => task, :repos => repos}
-        end
+        repos = task.output[:results]
+        repos = exclude_rolling_kickstart_repos(repos)
+        repos = available_synced_repos(repos, params[:content_id])
+
+        locals = {:scan_cdn => task, :repos => repos, :error_message => nil}
+        locals[:error_message => task_error(task)] if task.result == 'warning'
+        render :partial => 'katello/providers/redhat/repos', :locals => locals
       end
     end
 
@@ -80,8 +79,8 @@ module Katello
       end
     end
 
-    def available_synced_repos(repos)
-      @product.repositories.each do |product_repo|
+    def available_synced_repos(repos, content_id)
+      @product.repositories.in_default_view.where(:content_id => content_id).find_each do |product_repo|
         found = repos.detect do |repo|
           product_repo.pulp_id == repo[:pulp_id]
         end

data/app/controllers/katello/providers_controller.rb

@@ -24,8 +24,9 @@ module Katello
         subscription_product_ids += sub['derivedProvidedProducts'].map { |p| p['id'] } if sub['derivedProvidedProducts']
       end
 
-      orphaned_product_ids = current_organization.redhat_provider.products.
-          where("cp_id not in (?)", subscription_product_ids).pluck(:id)
+      orphaned_products = current_organization.redhat_provider.products
+      orphaned_products = orphaned_products.where("cp_id not in (?)", subscription_product_ids) if subscription_product_ids.any?
+      orphaned_product_ids = orphaned_products.pluck(:id)
 
       render :partial => "katello/providers/redhat/tab",
              :locals => { :tab_id => params[:tab], :orphaned_product_ids => orphaned_product_ids }

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -14,14 +14,6 @@ module Katello
       %(<option data-id="#{inherited_value}" value="">#{blank_or_inherit_f(f, attr)}</option>)
     end
 
-    def envs_by_kt_org
-      ::Environment.all.find_all(&:katello_id).group_by do |env|
-        if env.katello_id
-          env.katello_id.split('/').first
-        end
-      end
-    end
-
     def content_view(host)
       if host.is_a?(Hostgroup)
         host.content_view
@@ -30,6 +22,14 @@ module Katello
       end
     end
 
+    def organizations(host)
+      if host.is_a?(Hostgroup)
+        host.organizations
+      else
+        host.organization ? [host.organization] : []
+      end
+    end
+
     def lifecycle_environment(host)
       if host.is_a?(Hostgroup)
         host.lifecycle_environment
@@ -91,26 +91,49 @@ module Katello
       selected_content_view if selected_content_view.present?
     end
 
+    def accessible_lifecycle_environments(org, host)
+      selected = lifecycle_environment(host)
+      envs = org.kt_environments.readable
+      envs |= [selected] if selected.present? && org == selected.organization
+      envs
+    end
+
+    def accessible_content_proxies(obj)
+      list = accessible_resource_records(:smart_proxy).with_content.to_a
+      current = obj.content_source
+      list |= [current] if current.present?
+      list
+    end
+
+    def relevant_organizations(host)
+      host_orgs = organizations(host)
+      if Organization.current
+        [Organization.current]
+      elsif host_orgs.present?
+        host_orgs
+      else
+        Organization.my_organizations
+      end
+    end
+
     def lifecycle_environment_options(host, options = {})
       include_blank = options.fetch(:include_blank, nil)
-      if include_blank == true #check for true specifically
-        include_blank = '<option></option>'
-      end
-      selected_id = fetch_lifecycle_environment(host, options).try(:id)
+      include_blank = '<option></option>' if include_blank == true #check for true specifically
 
-      orgs = Organization.current ? [Organization.current] : Organization.my_organizations
+      selected_id = fetch_lifecycle_environment(host, options).try(:id)
+      orgs = relevant_organizations(host)
       all_options = []
       orgs.each do |org|
         env_options = ""
-        org.kt_environments.each do |env|
+        accessible_lifecycle_environments(org, host).each do |env|
           selected = selected_id == env.id ? 'selected' : ''
           env_options << %(<option value="#{env.id}" class="kt-env" #{selected}>#{h(env.name)}</option>)
         end
 
-        if Organization.current
-          all_options << env_options
-        else
+        if orgs.count > 1
           all_options << %(<optgroup label="#{org.name}">#{env_options}</optgroup>)
+        else
+          all_options << env_options
         end
       end
 
@@ -129,7 +152,8 @@ module Katello
 
       views = []
       if lifecycle_environment
-        views = Katello::ContentView.in_environment(lifecycle_environment)
+        views = Katello::ContentView.in_environment(lifecycle_environment).readable
+        views |= [content_view] if content_view.present? && content_view.in_environment?(lifecycle_environment)
       elsif content_view
         views = [content_view]
       end
@@ -180,13 +204,13 @@ module Katello
 
         if (host.is_a? Hostgroup)
           new_host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => host.lifecycle_environment_id,
-                                                          :content_view_id => host.content_view_id)
+                                                          :content_view_id => host.content_view_id,
+                                                          :content_source_id => host.content_source_id)
         elsif host.content_facet.present?
           new_host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => host.content_facet.lifecycle_environment_id,
-                                                          :content_view_id => host.content_facet.content_view_id)
+                                                          :content_view_id => host.content_facet.content_view_id,
+                                                          :content_source_id => host.content_source_id)
         end
-
-        new_host.content_source = host.content_source
         new_host.operatingsystem.kickstart_repos(new_host).map { |repo| OpenStruct.new(repo) }
       else
         # case 2
@@ -213,8 +237,8 @@ module Katello
         lifecycle_env = Katello::KTEnvironment.find(host_params[:lifecycle_environment_id])
         content_view = Katello::ContentView.find(host_params[:content_view_id])
         host.content_facet = Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_env.id,
-                                                    :content_view_id => content_view.id)
-        host.content_source = SmartProxy.find(host_params[:content_source_id])
+                                                    :content_view_id => content_view.id,
+                                                    :content_source => SmartProxy.find(host_params[:content_source_id]))
         if host.operatingsystem.is_a?(Redhat)
           view_options = host.operatingsystem.kickstart_repos(host).map { |repo| OpenStruct.new(repo) }
         end

data/app/lib/actions/katello/repository/clear.rb

@@ -8,7 +8,8 @@ module Actions
            Pulp::Repository::RemovePackageGroup,
            Pulp::Repository::RemoveDistribution,
            Pulp::Repository::RemoveFile,
-           Pulp::Repository::RemovePuppetModule].each do |action_class|
+           Pulp::Repository::RemovePuppetModule,
+           Pulp::Repository::RemoveDockerManifest].each do |action_class|
             plan_action(action_class, pulp_id: repo.pulp_id)
           end
         end

data/app/lib/actions/katello/repository/clone_docker_content.rb

@@ -2,14 +2,20 @@ module Actions
   module Katello
     module Repository
       class CloneDockerContent < Actions::Base
-        def plan(source_repo, target_repo)
+        def plan(source_repo, target_repo, filters)
+          filters = filters.docker unless filters.is_a? Array
+
+          if filters.any?
+            clause_gen = ::Katello::Util::DockerManifestClauseGenerator.new(source_repo, filters)
+            clause_gen.generate
+            copy_clauses = clause_gen.copy_clause
+          end
+
           sequence do
-            plan_action(Pulp::Repository::CopyDockerManifest,
-                        source_pulp_id: source_repo.pulp_id,
-                        target_pulp_id: target_repo.pulp_id)
-            plan_action(Pulp::Repository::CopyDockerTag,
-                        source_pulp_id: source_repo.pulp_id,
-                        target_pulp_id: target_repo.pulp_id)
+            if filters.empty? || copy_clauses
+              plan_action(Pulp::Repository::CopyDockerTag, source_pulp_id: source_repo.pulp_id,
+                          target_pulp_id: target_repo.pulp_id, clauses: copy_clauses)
+            end
             plan_action(Katello::Repository::MetadataGenerate, target_repo)
             plan_action(Katello::Repository::IndexContent, id: target_repo.id)
           end

data/app/lib/actions/katello/repository/clone_to_environment.rb

@@ -23,7 +23,7 @@ module Actions
             if repository.yum?
               plan_action(Repository::CloneYumContent, repository, clone, [], false)
             elsif repository.docker?
-              plan_action(Repository::CloneDockerContent, repository, clone)
+              plan_action(Repository::CloneDockerContent, repository, clone, [])
             elsif repository.ostree?
               plan_action(Repository::CloneOstreeContent, repository, clone)
             elsif repository.file?

data/app/lib/actions/katello/repository/clone_to_version.rb

@@ -20,7 +20,7 @@ module Actions
                 plan_action(Repository::CloneYumContent, repository, new_repository, filters, !incremental,
                             :generate_metadata => !incremental, :index_content => !incremental, :simple_clone => incremental)
               elsif new_repository.docker?
-                plan_action(Repository::CloneDockerContent, repository, new_repository)
+                plan_action(Repository::CloneDockerContent, repository, new_repository, filters)
               elsif new_repository.ostree?
                 plan_action(Repository::CloneOstreeContent, repository, new_repository)
               elsif new_repository.file?

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

@@ -0,0 +1,44 @@
+module Katello
+  module Util
+    class DockerManifestClauseGenerator
+      include Util::FilterClauseGenerator
+
+      protected
+
+      def fetch_filters
+        ContentViewFilter.docker
+      end
+
+      def collect_clauses(repo, filters)
+        [ContentViewDockerFilter].collect do |filter_class|
+          content_type_filters = filters.where(:type => filter_class)
+          make_manifest_clauses(repo, content_type_filters) unless content_type_filters.empty?
+        end
+      end
+
+      def whitelist_non_matcher_clause
+        {"name" => {"$not" => {"$exists" => true}}}
+      end
+
+      def whitelist_all_matcher_clause
+        {"name" => {"$exists" => true}}
+      end
+
+      def make_manifest_clauses(repo, filters)
+        pulp_content_clauses = filters.collect do |filter|
+          filter.generate_clauses(repo)
+        end
+        pulp_content_clauses.flatten!
+        pulp_content_clauses.compact!
+
+        unless pulp_content_clauses.empty?
+          manifest_clauses_from_content(pulp_content_clauses)
+        end
+      end
+
+      def manifest_clauses_from_content(pulp_content_clauses)
+        {"$or" => pulp_content_clauses}
+      end
+    end
+  end
+end

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

@@ -31,16 +31,35 @@ module Katello
       end
 
       def results
-        epoch_clause = "epoch #{operator} :epoch OR (epoch = :epoch AND (%s))"
         version_clause = "#{convert(:version_sortable)} #{operator} #{convert(':version')}"
-        release_clause = "(#{convert(:version_sortable)} = #{convert(':version')} AND " \
-            "#{convert(:release_sortable)} #{operator} #{convert(':release')})"
+        version_clause = add_release_clause(version_clause) unless release.blank?
+        version_clause = add_epoch_clause(version_clause) unless epoch.blank?
 
-        version_clause = "#{version_clause} OR #{release_clause}" unless release.blank?
-        version_clause = epoch_clause % version_clause unless epoch.blank?
         self.relation.where(version_clause, :version => version, :release => release, :epoch => epoch)
       end
 
+      def add_release_clause(version_clause)
+        clause = "(#{convert(:version_sortable)} = #{convert(':version')} AND #{convert(:release_sortable)} #{operator} #{convert(':release')})"
+
+        # if we're using EQUAL, match: version = X AND release = Y
+        # else if we're using something like greater than, we need:
+        #   (version > X) OR (version = X AND release > Y)
+        if operator == EQUAL
+          clause
+        else
+          "#{version_clause} OR #{clause}"
+        end
+      end
+
+      def add_epoch_clause(version_clause)
+        if operator == EQUAL
+          clause = "(epoch = :epoch AND (%s))"
+        else
+          clause = "epoch #{operator} :epoch OR (epoch = :epoch AND (%s))"
+        end
+        clause % version_clause
+      end
+
       def convert(name = '?')
         "convert_to(#{name}, 'SQL_ASCII')"
       end

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

@@ -18,6 +18,7 @@ module Katello
         #associations for simpler scoped searches
         has_one :content_view, :through => :content_facet
         has_one :lifecycle_environment, :through => :content_facet
+        has_one :content_source, :through => :content_facet
         has_many :applicable_errata, :through => :content_facet
         has_many :applicable_rpms, :through => :content_facet
 
@@ -29,6 +30,7 @@ module Katello
         scoped_search :in => :applicable_errata, :on => :errata_id, :rename => :installable_errata, :complete_value => true, :ext_method => :find_by_installable_errata, :only_explicit => true
         scoped_search :in => :applicable_rpms, :on => :nvra, :rename => :applicable_rpms, :complete_value => true, :ext_method => :find_by_applicable_rpms, :only_explicit => true
         scoped_search :in => :applicable_rpms, :on => :nvra, :rename => :upgradable_rpms, :complete_value => true, :ext_method => :find_by_installable_rpms, :only_explicit => true
+        scoped_search :in => :content_source, :on => :name, :complete_value => true, :rename => :content_source
 
         # preserve options set by facets framework, but add new :reject_if statement
         accepts_nested_attributes_for(
@@ -95,5 +97,5 @@ module Katello
 end
 
 class ::Host::Managed::Jail < Safemode::Jail
-  allow :content_view, :lifecycle_environment
+  allow :content_view, :lifecycle_environment, :content_source
 end