katello 3.13.4 → 3.14.0.rc1

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

@@ -22,7 +22,7 @@ module Katello
     api :GET, "/activation_keys/:activation_key_id/subscriptions", N_("List an activation key's subscriptions")
     api :GET, "/subscriptions"
     param_group :search, Api::V2::ApiController
-    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => false
     param :host_id, String, :desc => N_("id of a host"), :required => false
     param :activation_key_id, String, :desc => N_("Activation key ID"), :required => false
     param :available_for, String, :desc => N_("Object to show subscriptions available for, either 'host' or 'activation_key'"), :required => false
@@ -75,7 +75,11 @@ module Katello
     param :organization_id, :number, :desc => N_("Organization identifier")
     param :id, :number, :desc => N_("Subscription identifier"), :required => true
     def show
+      org_id = Organization.current&.id
       @resource = Katello::Pool.with_identifier(params[:id])
+      if @resource.organization_id != org_id
+        fail ActiveRecord::RecordNotFound, N_('This subscription is not relevant to the current organization.')
+      end
       respond(:resource => @resource)
     end
 

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

@@ -18,7 +18,7 @@ module Katello
 
     api :GET, "/sync_plans", N_("List sync plans")
     api :GET, "/organizations/:organization_id/sync_plans"
-    param :organization_id, :number, :desc => N_("Filter sync plans by organization name or label"), :required => true
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     param :name, String, :desc => N_("filter by name")
     param :sync_date, String, :desc => N_("filter by sync date")
     param :interval, SyncPlan::TYPES, :desc => N_("filter by interval")
@@ -38,14 +38,14 @@ module Katello
 
     api :GET, "/organizations/:organization_id/sync_plans/:id", N_("Show a sync plan")
     api :GET, "/sync_plans/:id", N_("Show a sync plan")
-    param :organization_id, :number, :desc => N_("Filter sync plans by organization name or label")
+    param :organization_id, :number, :desc => N_("Organization ID")
     param :id, :number, :desc => N_("sync plan numeric identifier"), :required => true
     def show
       respond_for_show(:resource => @sync_plan)
     end
 
     api :POST, "/organizations/:organization_id/sync_plans", N_("Create a sync plan")
-    param :organization_id, :number, :desc => N_("Filter sync plans by organization name or label"), :required => true
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     param_group :sync_plan
     def create
       if params[:sync_plan].key?(:enabled) || params.key?(:enabled)
@@ -62,7 +62,7 @@ module Katello
 
     api :PUT, "/organizations/:organization_id/sync_plans/:id", N_("Update a sync plan")
     api :PUT, "/sync_plans/:id", N_("Update a sync plan")
-    param :organization_id, :number, :desc => N_("Filter sync plans by organization name or label")
+    param :organization_id, :number, :desc => N_("Organization ID")
     param :id, :number, :desc => N_("sync plan numeric identifier"), :required => true
     param_group :sync_plan
     def update
@@ -79,13 +79,14 @@ module Katello
 
     api :DELETE, "/organizations/:organization_id/sync_plans/:id", N_("Destroy a sync plan")
     api :DELETE, "/sync_plans/:id", N_("Destroy a sync plan")
-    param :organization_id, :number, :desc => N_("Filter sync plans by organization name or label")
+    param :organization_id, :number, :desc => N_("Organization ID")
     param :id, :number, :desc => N_("sync plan numeric identifier")
     def destroy
       @sync_plan.destroy!
     end
 
     api :PUT, "/organizations/:organization_id/sync_plans/:id/add_products", N_("Add products to sync plan")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     param :id, String, :desc => N_("ID of the sync plan"), :required => true
     param :product_ids, Array, :desc => N_("List of product ids to add to the sync plan"), :required => true
     def add_products
@@ -96,6 +97,7 @@ module Katello
     end
 
     api :PUT, "/organizations/:organization_id/sync_plans/:id/remove_products", N_("Remove products from sync plan")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     param :id, String, :desc => N_("ID of the sync plan"), :required => true
     param :product_ids, Array, :desc => N_("List of product ids to remove from the sync plan"), :required => true
     def remove_products

data/app/controllers/katello/concerns/api/v2/repository_content_controller.rb

@@ -10,7 +10,7 @@ module Katello
         before_action :find_optional_organization, :only => [:index, :auto_complete_search]
         before_action :find_environment, :only => [:index, :auto_complete_search]
         before_action :find_content_view_version, :only => [:index, :auto_complete_search]
-        before_action :find_filter, :only => [:index, :auto_complete_search]
+        before_action :find_filter, :find_filter_rule, :only => [:index, :auto_complete_search]
         before_action :find_content_resource, :only => [:show]
       end
 
@@ -23,6 +23,7 @@ module Katello
       param :organization_id, :number, :desc => N_("organization identifier")
       param :content_view_version_id, :number, :desc => N_("content view version identifier")
       param :content_view_filter_id, :number, :desc => N_("content view filter identifier")
+      param :content_view_filter_rule_id, :number, :desc => N_("content view filter rule identifier")
       param :repository_id, :number, :desc => N_("repository identifier")
       param :environment_id, :number, :desc => N_("environment identifier")
       param :ids, Array, :desc => N_("ids to filter content by")
@@ -79,12 +80,20 @@ module Katello
 
         collection = filter_by_repos(repos, collection)
         collection = filter_by_ids(params[:ids], collection) if params[:ids]
+
         @filter = ContentViewFilter.find(params[:filterId]) if params[:filterId]
         if params[:available_for] == "content_view_filter" && self.respond_to?(:available_for_content_view_filter)
           collection = self.available_for_content_view_filter(@filter, collection) if @filter
         else
-          collection = filter_by_content_view_filter(@filter, collection) if @filter
+          # Filtering by the CV filter rule makes filtering by the CV filter redundant, keeping these
+          # exclusive to keep the queries simple.
+          if @filter_rule
+            collection = filter_by_content_view_filter_rule(@filter_rule, collection)
+          elsif @filter
+            collection = filter_by_content_view_filter(@filter, collection)
+          end
         end
+
         collection = self.custom_index_relation(collection) if self.respond_to?(:custom_index_relation)
         collection
       end
@@ -105,9 +114,12 @@ module Katello
         end
       end
 
-      def filter_by_content_view_filter(filter, collection)
-        ids = filter.send("#{singular_resource_name}_rules").pluck(:uuid)
-        filter_by_ids(ids, collection)
+      def filter_by_content_view_filter(_filter, _collection)
+        fail NotImplementedError, "Unsupported content type for content view filter parameter"
+      end
+
+      def filter_by_content_view_filter_rule(_filter, _collection)
+        fail NotImplementedError, "Unsupported content type for content view filter rule parameter"
       end
 
       def repos
@@ -193,6 +205,19 @@ module Katello
         end
       end
 
+      def find_filter_rule
+        filter_rule_id = params[:content_view_filter_rule_id]
+
+        if filter_rule_id
+          @filter_rule = filter_rule_class_name.constantize.find_by(:id => filter_rule_id)
+
+          unless @filter_rule
+            fail HttpErrors::NotFound, _("Couldn't find %{type} Filter with id %{id}") %
+              {:type => resource_name, :id => filter_rule_id}
+          end
+        end
+      end
+
       def resource_class
         "Katello::#{controller_name.classify}".constantize
       end
@@ -205,6 +230,10 @@ module Katello
         "Katello::ContentView#{controller_name.classify}Filter"
       end
 
+      def filter_rule_class_name
+        "Katello::ContentView#{controller_name.classify}FilterRule"
+      end
+
       def resource_name(_i18n = true)
         case resource_class.to_s
         when "Katello::Erratum"
@@ -213,6 +242,8 @@ module Katello
           _("Deb Package")
         when "Katello::Rpm"
           _("Package")
+        when "Katello::Srpm"
+          _("Source RPM")
         when "Katello::PackageGroup"
           _("Package Group")
         when "Katello::PuppetModule"

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -248,5 +248,17 @@ module Katello
       end
       view_options
     end
+
+    def content_host_overview_button(host)
+      return [] unless host.content_facet || host.subscription_facet
+      [{
+        :button => link_to(
+          _('Content'),
+          "/content_hosts/#{host.id}",
+          :title => _("Host content and subscription details"),
+          :class => 'btn btn-default'),
+        :priority => 900
+      }]
+    end
   end
 end

data/app/lib/actions/katello/capsule_content/refresh_repos.rb

@@ -0,0 +1,55 @@
+module Actions
+  module Katello
+    module CapsuleContent
+      module RefreshRepos
+        def fetch_proxy_service(_smart_proxy)
+          fail NotImplementedError
+        end
+
+        def act_on_repo?(_repo)
+          fail NotImplementedError
+        end
+
+        def plan(smart_proxy, options = {})
+          plan_self(:smart_proxy_id => smart_proxy.id,
+                    :environment_id => options[:environment]&.id,
+                    :content_view_id => options[:content_view]&.id,
+                    :repository_id => options[:repository]&.id)
+        end
+
+        def invoke_external_task
+          tasks = []
+          environment = ::Katello::KTEnvironment.find_by(:id => input[:environment_id]) if input[:environment_id]
+          repository = ::Katello::Repository.find_by(:id => input[:repository_id]) if input[:repository_id]
+          if repository.nil? && input[:repository_id]
+            repository = ::Katello::ContentViewPuppetEnvironment.find(input[:repository_id])
+            repository = repository.nonpersisted_repository
+          end
+          content_view = ::Katello::ContentView.find_by(:id => input[:content_view_id]) if input[:content_view_id]
+          smart_proxy = SmartProxy.unscoped.find(input[:smart_proxy_id])
+          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+          smart_proxy_service = fetch_proxy_service(smart_proxy)
+
+          current_repos_on_capsule = smart_proxy_service.current_repositories(environment, content_view)
+          current_repos_on_capsule_ids = current_repos_on_capsule.pluck(:id)
+
+          list_of_repos_to_sync = smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository)
+          list_of_repos_to_sync.each do |repo|
+            if repo.is_a?(Katello::ContentViewPuppetEnvironment)
+              repo = repo.nonpersisted_repository
+            end
+            next unless act_on_repo?(repo, smart_proxy)
+
+            pulp_repo = repo.backend_service(smart_proxy)
+            if !current_repos_on_capsule_ids.include?(repo.id)
+              pulp_repo.create_mirror_entities
+            elsif pulp_repo.mirror_needs_updates?
+              tasks += pulp_repo.refresh_mirror_entities
+            end
+          end
+          tasks
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/capsule_content/sync.rb

@@ -15,85 +15,34 @@ module Actions
         end
 
         def humanized_input
-          ["'#{input['smart_proxy']['name']}'"] + super
+          input['smart_proxy'].nil? || input['smart_proxy']['name'].nil? ? super : ["'#{input['smart_proxy']['name']}'"] + super
         end
 
         # rubocop:disable MethodLength
         def plan(smart_proxy, options = {})
           action_subject(smart_proxy)
-          smart_proxy_service = ::Katello::Pulp::SmartProxyRepository.new(smart_proxy)
-          smart_proxy.ping_pulp
           smart_proxy.verify_ueber_certs
-
           environment_id = options.fetch(:environment_id, nil)
           environment = ::Katello::KTEnvironment.find(environment_id) if environment_id
           repository_id = options.fetch(:repository_id, nil)
           repository = ::Katello::Repository.find(repository_id) if repository_id
           content_view_id = options.fetch(:content_view_id, nil)
           content_view = ::Katello::ContentView.find(content_view_id) if content_view_id
-          skip_metadata_check = options.fetch(:skip_metadata_check, false)
 
           fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_master?
 
-          repository_ids = smart_proxy_service.get_repository_ids(environment, content_view, repository)
-          # Create a list of non-puppet repos to sync first, and then sync puppet repos last.
-          # Puppet modules may refer to non-puppet content in the same CV, and thus need to publish last.
-          puppet_repository_ids = []
-          non_puppet_repository_ids = []
-          repository_ids.each do |repo_id|
-            repo = ::Katello::Repository.find_by(pulp_id: repo_id) || ::Katello::ContentViewPuppetEnvironment.find_by(pulp_id: repo_id)
-            repo.content_type == 'puppet' ? puppet_repository_ids << repo_id : non_puppet_repository_ids << repo_id
-          end
-
-          unless repository_ids.blank?
-            sequence do
-              options = {}
-              options[:environment_id] = environment_id if environment_id
-              options[:content_view_id] = content_view_id if content_view_id
-              options[:repository_id] = repository_id if repository_id
-
-              plan_action(Pulp::Repository::RefreshNeeded, smart_proxy, options)
-              plan_action(CreateRepos, smart_proxy, environment, content_view, repository)
-              sync_repos_to_capsule(smart_proxy_service, non_puppet_repository_ids, skip_metadata_check) unless non_puppet_repository_ids.blank?
-              sync_repos_to_capsule(smart_proxy_service, puppet_repository_ids, skip_metadata_check) unless puppet_repository_ids.blank?
-            end
-          end
-        end
-
-        def sync_repos_to_capsule(smart_proxy_service, repository_ids, skip_metadata_check)
-          concurrence do
-            repository_ids.each do |repo_id|
-              sequence do
-                repo = ::Katello::Repository.find_by(pulp_id: repo_id) ||
-                        ::Katello::ContentViewPuppetEnvironment.find_by(pulp_id: repo_id)
-                if repo && ['yum', 'puppet'].exclude?(repo.content_type)
-                  # we unassociate units in non-yum/puppet repos in order to avoid version conflicts
-                  # during publish. (i.e. two versions of a unit in the same repo)
-                  plan_action(Pulp::Consumer::UnassociateUnits,
-                              capsule_id: smart_proxy_service.smart_proxy.id,
-                              repo_pulp_id: repo_id)
-                end
-                pulp_options = { remove_missing: repo && ["deb", "puppet", "yum"].include?(repo.content_type) }
-                pulp_options[:force_full] = true if skip_metadata_check && repo.content_type == "yum"
-                plan_action(Pulp::Consumer::SyncCapsule,
-                            capsule_id: smart_proxy_service.smart_proxy.id,
-                            repo_pulp_id: repo_id,
-                            sync_options: pulp_options)
-                if skip_metadata_check
-                  plan_action(Katello::Repository::MetadataGenerate,
-                              repo,
-                              capsule_id: smart_proxy_service.smart_proxy.id,
-                              force: true)
-                end
-                if repo.is_a?(::Katello::Repository) &&
-                   repo.distribution_bootable? &&
-                   repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
-                  plan_action(Katello::Repository::FetchPxeFiles,
-                              id: repo.id,
-                              capsule_id: smart_proxy_service.smart_proxy.id)
-                end
-              end
-            end
+          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+          repositories = smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository)
+          smart_proxy.ping_pulp3 if repositories.any? { |repo| smart_proxy.pulp3_support?(repo) }
+          smart_proxy.ping_pulp if repositories.any? { |repo| !smart_proxy.pulp3_support?(repo) }
+
+          refresh_options = options.merge(content_view: content_view,
+                                             environment:  environment,
+                                             repository: repository)
+          sequence do
+            plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.pulp3_enabled?
+            plan_action(SyncCapsule, smart_proxy, refresh_options)
           end
         end
 

data/app/lib/actions/katello/capsule_content/sync_capsule.rb

@@ -0,0 +1,40 @@
+module Actions
+  module Katello
+    module CapsuleContent
+      class SyncCapsule < ::Actions::EntryAction
+        include Actions::Katello::PulpSelector
+
+        # rubocop:disable MethodLength
+        def plan(smart_proxy, options = {})
+          action_subject(smart_proxy)
+          environment = options[:environment]
+          content_view = options[:content_view]
+          repository = options[:repository]
+          skip_metadata_check = options.fetch(:skip_metadata_check, false)
+
+          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
+          concurrence do
+            smart_proxy_helper.repos_available_to_capsule(environment, content_view, repository).each do |repo|
+              plan_pulp_action([Actions::Pulp::Orchestration::Repository::SmartProxySync,
+                                Actions::Pulp3::CapsuleContent::Sync],
+                                 repo, smart_proxy,
+                                 skip_metadata_check: skip_metadata_check)
+
+              if repo.is_a?(::Katello::Repository) &&
+                repo.distribution_bootable? &&
+                repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+                plan_action(Katello::Repository::FetchPxeFiles,
+                            id: repo.id,
+                            capsule_id: smart_proxy.id)
+              end
+            end
+          end
+        end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/content_view/publish.rb

@@ -76,9 +76,6 @@ module Actions
               attrs[:metadata] = metadata
             end
           end
-
-          output[:content_view_id] = input[:content_view_id]
-          output[:content_view_version_id] = input[:content_view_version_id]
         end
 
         def rescue_strategy_for_self

data/app/lib/actions/katello/content_view_puppet_environment/destroy.rb

@@ -4,9 +4,7 @@ module Actions
       class Destroy < Actions::EntryAction
         def plan(puppet_env)
           action_subject(puppet_env)
-          if ::Katello::RepositoryTypeManager.enabled?('puppet')
-            plan_action(Pulp::Repository::Destroy, content_view_puppet_environment_id: puppet_env.id)
-          end
+          plan_action(Pulp::Repository::Destroy, content_view_puppet_environment_id: puppet_env.id)
           plan_self
         end
 

data/app/lib/actions/katello/orphan_cleanup/remove_orphans.rb

@@ -0,0 +1,21 @@
+module Actions
+  module Katello
+    module OrphanCleanup
+      class RemoveOrphans < Pulp::Abstract
+        input_format do
+          param :capsule_id
+        end
+        def plan(proxy)
+          sequence do
+            plan_action(Actions::Pulp::Orchestration::OrphanCleanup::RemoveOrphans, proxy)
+            if proxy.pulp3_enabled?
+              plan_action(
+                Actions::Pulp3::Orchestration::OrphanCleanup::RemoveOrphans,
+                proxy)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,14 @@ module Actions
 
           action_subject(repository)
 
+          if repository.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_BACKGROUND
+            ::Foreman::Deprecation.api_deprecation_warning("Background download_policy will be removed in Katello 3.16.  Any background repositories will be converted to Immediate")
+          end
+
+          if root['content_type'] == 'puppet' || root['content_type'] == 'ostree'
+            ::Foreman::Deprecation.api_deprecation_warning("Repository types of 'Puppet' and 'OSTree' will no longer be supported in Katello 3.16.")
+          end
+
           org = repository.organization
           pulp2_create_action = plan_create ? Actions::Pulp::Repository::CreateInPlan : Actions::Pulp::Repository::Create
           sequence do