katello 3.17.0 → 3.18.0

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

@@ -4,8 +4,10 @@ module Katello
 
     include Katello::Concerns::FilteredAutoCompleteSearch
     before_action :find_organization, :only => [:create, :index, :auto_complete_search]
-    before_action :find_plan, :only => [:update, :show, :destroy, :sync,
-                                        :add_products, :remove_products]
+    before_action :find_authorized_katello_resource, :only => [:update, :show, :destroy, :sync,
+                                                               :add_products, :remove_products]
+    before_action :set_organization, :only => [:update, :show, :destroy, :sync,
+                                               :add_products, :remove_products]
 
     def_param_group :sync_plan do
       param :name, String, :desc => N_("sync plan name"), :required => true, :action_aware => true
@@ -117,16 +119,13 @@ module Katello
 
     protected
 
-    def find_plan
-      @sync_plan = SyncPlan.find_by(:id => params[:id])
-      fail HttpErrors::NotFound, _("Couldn't find sync plan '%{plan}' in organization '%{org}'") % { :plan => params[:id], :org => params[:organization_id] } if @sync_plan.nil?
-      @organization ||= @sync_plan.organization
-      @sync_plan
-    end
-
     def sync_plan_params
       params[:sync_plan][:enabled] = params[:enabled] unless params[:enabled].nil?
       params.require(:sync_plan).permit(:name, :description, :interval, :sync_date, :product_ids, :enabled, :cron_expression)
     end
+
+    def set_organization
+      @organization ||= @sync_plan.try(:organization)
+    end
   end
 end

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

@@ -77,7 +77,14 @@ module Katello
       render json: { status: 'OK' }
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/enable",
+    api :GET, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/eligible",
+      N_("Check if the specified organization is eligible for Simple Content Access")
+    def simple_content_access_eligible
+      eligible = @organization.upstream_consumer.simple_content_access_eligible?
+      render json: { simple_content_access_eligible: eligible }
+    end
+
+    api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/enable",
       N_("Enable simple content access for a manifest")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def enable_simple_content_access
@@ -85,7 +92,7 @@ module Katello
       respond_for_async :resource => task
     end
 
-    api :PUT, "/organizations/:organization_id/simple_content_access/disable",
+    api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/disable",
       N_("Disable simple content access for a manifest")
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def disable_simple_content_access

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

@@ -21,12 +21,16 @@ module Katello
       end
 
       def find_authorized_katello_resource
-        finder_scope = ::Foreman::AccessControl.permissions_for_controller_action(path_to_authenticate).first&.finder_scope
-        if finder_scope
-          instance_variable_set("@#{resource_name}", resource_class.send(finder_scope).find_by(:id => params[:id]))
+        found_entity = nil
+        ::Foreman::AccessControl.permissions_for_controller_action(path_to_authenticate).each do |permission|
+          next unless found_entity.blank?
+          finder_scope = permission&.finder_scope
+          if finder_scope
+            found_entity = resource_class.send(finder_scope).find_by(:id => params[:id])
+          end
         end
-
-        throw_resource_not_found if instance_variable_get("@#{resource_name}").nil?
+        throw_resource_not_found if found_entity.blank?
+        instance_variable_set("@#{resource_name}", found_entity)
       end
 
       def find_unauthorized_katello_resource
@@ -38,6 +42,16 @@ module Katello
         fail HttpErrors::NotFound, _("Could not find %{name} resource with id %{id}") % {id: id, name: name}
       end
 
+      def throw_resources_not_found(name:, expected_ids: [])
+        resources = yield
+        found_ids = resources.map(&:id)
+        missing_ids = expected_ids.map(&:to_i) - found_ids
+
+        if missing_ids.any?
+          fail HttpErrors::NotFound, _("Could not find %{name} resources with ids %{ids}") % {ids: missing_ids.join(', '), name: name}
+        end
+      end
+
       def check_association_ids
         if filtered_associations
           wrapped_params = params[self._wrapper_options.name]

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

@@ -3,37 +3,41 @@ module Katello
     module Api::V2::BulkHostsExtensions
       extend ActiveSupport::Concern
 
+      def bulk_hosts_relation(permission, org)
+        relation = ::Host::Managed.authorized(permission)
+        relation = relation.where(organization: org) if org
+        relation
+      end
+
       def find_bulk_hosts(permission, bulk_params, restrict_to = nil)
         #works on a structure of param_group bulk_params and transforms it into a list of systems
-        find_organization
         bulk_params[:included] ||= {}
         bulk_params[:excluded] ||= {}
-        @hosts = []
 
-        unless bulk_params[:included][:ids].blank?
-          @hosts = ::Host::Managed.authorized(permission).where(:id => bulk_params[:included][:ids])
-          @hosts = @hosts.where(:organization_id => @organization.id) if @organization
+        if bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
+          fail HttpErrors::BadRequest, _("No hosts have been specified.")
+        end
+
+        find_organization
+        @hosts = bulk_hosts_relation(permission, @organization)
+
+        if bulk_params[:included][:ids].present?
+          @hosts = @hosts.where(id: bulk_params[:included][:ids])
         end
 
         if bulk_params[:included][:search]
-          search_hosts = ::Host::Managed.authorized(permission)
-          search_hosts = search_hosts.where(:organization_id => @organization.id) if @organization
-          search_hosts = search_hosts.search_for(bulk_params[:included][:search])
-          if @hosts.any?
-            @hosts = ::Host.where(id: @hosts).or(::Host.where(id: search_hosts))
-          else
-            @hosts = search_hosts
-          end
+          search_hosts = bulk_hosts_relation(permission, @organization).search_for(bulk_params[:included][:search])
+          @hosts = @hosts.merge(search_hosts)
         end
 
         @hosts = restrict_to.call(@hosts) if restrict_to
-        @hosts = @hosts.where.not(id: bulk_params[:excluded][:ids]) unless bulk_params[:excluded][:ids].blank?
 
-        if bulk_params[:included][:ids].blank? && bulk_params[:included][:search].nil?
-          fail HttpErrors::BadRequest, _("No hosts have been specified.")
-        elsif @hosts.empty?
-          fail HttpErrors::Forbidden, _("Action unauthorized to be performed on selected hosts.")
+        if bulk_params[:excluded][:ids].present?
+          @hosts = @hosts.where.not(id: bulk_params[:excluded][:ids])
         end
+
+        fail HttpErrors::Forbidden, _("Action unauthorized to be performed on selected hosts.") if @hosts.empty?
+
         @hosts
       end
 

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

@@ -0,0 +1,21 @@
+module Katello
+  module Concerns
+    module Api::V2::RegistrationControllerExtensions
+      extend ActiveSupport::Concern
+
+      def prepare_host
+        if params['uuid']
+          @host = Katello::Host::SubscriptionFacet.find_by(uuid: params['uuid'])&.host
+          if @host.nil?
+            msg = N_("Host was not found by the subscription UUID: '%s', this can happen if the host is registered already, but not to this Foreman") % params['uuid']
+            fail ActiveRecord::RecordNotFound, msg
+          end
+          @host.assign_attributes(host_params('host'))
+          @host.save!
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -60,7 +60,7 @@ module Katello
           collection = custom_collection_by_content_view_version(@versions)
         else
           repos = Katello::Repository.where(:content_view_version_id => @versions.pluck(:id))
-          repos = repos.where(:library_instance_id => @repo.id) if @repo
+          repos = repos.where(:root_id => @repo.root_id) if @repo
           collection = filter_by_repos(repos, resource_class.all)
         end
 

data/app/controllers/katello/concerns/organizations_controller_extensions.rb

@@ -7,7 +7,8 @@ module Katello
 
       module Overrides
         def edit
-          @can_toggle_sca = Katello::UpstreamConnectionChecker.new(@taxonomy).can_connect?
+          @can_toggle_sca = Katello::UpstreamConnectionChecker.new(@taxonomy).can_connect? &&
+            (@taxonomy.upstream_consumer.simple_content_access_eligible? || @taxonomy.simple_content_access?)
           super
         end
 

data/app/controllers/katello/concerns/registration_controller_extensions.rb

@@ -0,0 +1,16 @@
+module Katello
+  module Concerns
+    module RegistrationControllerExtensions
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :format_activation_key, only: [:create]
+      end
+
+      def format_activation_key
+        return if params[:activation_key].blank?
+        params[:activation_key] = params[:activation_key].split(',').map(&:strip).reject(&:blank?).join(',')
+      end
+    end
+  end
+end

data/app/helpers/katello/katello_urls_helper.rb

@@ -6,12 +6,15 @@ module Katello
       ::Setting[:foreman_url].sub(%r|^.*?:|, "#{schema}:")
     end
 
-    def subscription_manager_configuration_url(host = nil, rpm = true)
-      prefix = if host&.content_source
+    def subscription_manager_configuration_url(host = nil, rpm = true, hostname: nil)
+      prefix = if hostname
+                 "http://#{hostname}"
+               elsif host&.content_source
                  "http://#{host.content_source.hostname}"
                else
                  foreman_settings_url
                end
+
       config = rpm ? SETTINGS[:katello][:consumer_cert_rpm] : SETTINGS[:katello][:consumer_cert_sh]
 
       "#{prefix}/pub/#{config}"

data/app/lib/actions/candlepin/product/content_create.rb

@@ -9,6 +9,7 @@ module Actions
           param :label
           param :content_url
           param :owner
+          param :os_versions
         end
 
         def run
@@ -19,6 +20,7 @@ module Actions
                      type: input[:type],
                      arches: input[:arches],
                      label: input[:label],
+                     requiredTags: input[:os_versions],
                      metadataExpire: 1,
                      vendor: ::Katello::Provider::CUSTOM)
         end

data/app/lib/actions/candlepin/product/content_update.rb

@@ -7,6 +7,7 @@ module Actions
           param :name
           param :type
           param :arches
+          param :os_versions
           param :label
           param :content_url
           param :gpg_key_url
@@ -22,6 +23,7 @@ module Actions
                      gpgUrl: input[:gpg_key_url] || '', #candlepin ignores nil
                      type: input[:type],
                      arches: input[:arches],
+                     requiredTags: input[:os_versions],
                      label: input[:label],
                      metadataExpire: 1,
                      vendor: ::Katello::Provider::CUSTOM)

data/app/lib/actions/helpers/smart_proxy_sync_history_helper.rb

@@ -0,0 +1,24 @@
+module Actions
+  module Helpers
+    module SmartProxySyncHistoryHelper
+      def self.included(base)
+        base.middleware.use ::Actions::Middleware::RecordSmartProxySyncHistory
+      end
+
+      def done?
+        is_done = super
+        if is_done
+          ::Katello::SmartProxySyncHistory.where(:id => output[:smart_proxy_history_id], :finished_at => nil).update_all(finished_at: Time.now)
+        end
+        is_done
+      end
+
+      def rescue_external_task(error)
+        if output[:smart_proxy_history_id]
+          ::Katello::SmartProxySyncHistory.where(:id => output[:smart_proxy_history_id], :finished_at => nil).delete_all
+        end
+        super
+      end
+    end
+  end
+end

data/app/lib/actions/katello/applicability/hosts/bulk_generate.rb

@@ -9,8 +9,12 @@ module Actions
 
           def run
             input[:host_ids].each do |host_id|
-              content_facet = ::Host.find(host_id).content_facet
-              content_facet.calculate_and_import_applicability
+              content_facet = ::Katello::Host::ContentFacet.find_by_host_id(host_id)
+              if content_facet.present?
+                content_facet.calculate_and_import_applicability
+              else
+                Rails.logger.warn(_("Content Facet for host with id %s is non-existent. Skipping applicability calculation.") % host_id)
+              end
             end
           end
 

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

@@ -39,7 +39,7 @@ module Actions
                                              environment:  environment,
                                              repository: repository)
           sequence do
-            plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE)
             plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy) if repositories.any? { |repo| smart_proxy.pulp3_support?(repo) }
             plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options) if smart_proxy.pulp3_enabled?
             plan_action(SyncCapsule, smart_proxy, refresh_options)

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

@@ -9,9 +9,8 @@ module Actions
           content_view = options[:content_view]
           repository = options[:repository]
           skip_metadata_check = options.fetch(:skip_metadata_check, false)
-
           sequence do
-            repos = repos_to_sync(smart_proxy, environment, content_view, repository)
+            repos = repos_to_sync(smart_proxy, environment, content_view, repository, skip_metadata_check)
 
             repos.in_groups_of(Setting[:foreman_proxy_content_batch_size], false) do |repo_batch|
               concurrence do
@@ -20,7 +19,6 @@ module Actions
                                     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
@@ -34,22 +32,33 @@ module Actions
           end
         end
 
-        def repos_to_sync(smart_proxy, environment, content_view, repository)
+        def repos_to_sync(smart_proxy, environment, content_view, repository, skip_metatadata_check = false)
           smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
           smart_proxy_helper.lifecycle_environment_check(environment, repository)
-
           if repository
-            [repository]
+            if skip_metatadata_check || !repository.smart_proxy_sync_histories.where(:smart_proxy_id => smart_proxy).any? { |sph| !sph.finished_at.nil? }
+              [repository]
+            end
           else
             repositories = smart_proxy_helper.repositories_available_to_capsule(environment, content_view).by_rpm_count
             puppet_envs = smart_proxy_helper.puppet_environments_available_to_capsule(environment, content_view)
-            repositories + puppet_envs
+            repositories_to_skip = []
+            if skip_metatadata_check
+              smart_proxy_helper.clear_smart_proxy_sync_histories repositories
+            else
+              repositories_to_skip = ::Katello::Repository.synced_on_capsule smart_proxy
+            end
+            repositories - repositories_to_skip + puppet_envs
           end
         end
 
         def resource_locks
           :link
         end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end

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

@@ -71,7 +71,7 @@ module Actions
         private
 
         def sync_proxies?(environment)
-          Setting[:foreman_proxy_content_auto_sync] && ::SmartProxy.sync_needed?(environment)
+          ::SmartProxy.sync_needed?(environment)
         end
 
         def repos_to_delete(version, environment)

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

@@ -6,11 +6,10 @@ module Actions
         include ::Katello::ContentViewHelper
         attr_accessor :version
         # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
-        def plan(content_view, description = "", options = {})
+        def plan(content_view, description = "", options = {importing: false})
           action_subject(content_view)
-          import_only = options.fetch(:import_only, false)
-          path = options[:path]
-          content_view.check_ready_to_publish! unless import_only
+
+          content_view.check_ready_to_publish!(importing: options[:importing])
 
           if options[:repos_units].present?
             valid_labels_from_cv = content_view.repositories.map(&:label)
@@ -53,8 +52,9 @@ module Actions
 
             if separated_repo_map[:pulp3_yum].keys.flatten.present? &&
                 SmartProxy.pulp_primary.pulp3_support?(separated_repo_map[:pulp3_yum].keys.flatten.first)
-              if import_only
-                handle_import(version, path)
+
+              if options[:importing]
+                handle_import(version, options.slice(:path, :metadata))
               else
                 plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
               end
@@ -137,7 +137,7 @@ module Actions
           history.save!
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           view = ::Katello::ContentView.find(input[:content_view_id])
-          if SmartProxy.sync_needed?(environment) && Setting[:foreman_proxy_content_auto_sync] && !input[:skip_promotion]
+          if SmartProxy.sync_needed?(environment) && !input[:skip_promotion]
             ForemanTasks.async_task(ContentView::CapsuleSync,
                                     view,
                                     environment)
@@ -188,8 +188,8 @@ module Actions
           end
         end
 
-        def handle_import(version, path)
-          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path)
+        def handle_import(version, path:, metadata:)
+          plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::Import, version, path: path, metadata: metadata)
           plan_action(::Actions::Pulp3::Orchestration::ContentViewVersion::CopyVersionUnitsToLibrary, version)
           concurrence do
             version.importable_repositories.pluck(:id).each do |id|

data/app/lib/actions/katello/content_view_version/import.rb

@@ -2,27 +2,22 @@ module Actions
   module Katello
     module ContentViewVersion
       class Import < Actions::EntryAction
-        PULP_USER = 'pulp'.freeze
-
-        def plan(content_view, path:)
+        def plan(content_view, path:, metadata:)
           content_view.check_ready_to_import!
           unless SmartProxy.pulp_primary.pulp3_repository_type_support?(::Katello::Repository::YUM_TYPE)
-            fail HttpErrors::BadRequest, _("This API endpoint is only valid for Pulp 3 repositories.")
+            fail _("This action will become available after the Pulp 3 content migration")
           end
-          ::Katello::Pulp3::ContentViewVersion::Import.check_permissions!(path)
-          metadata = ::Katello::Pulp3::ContentViewVersion::Import.metadata(path)
+
+          ::Katello::Pulp3::ContentViewVersion::Import.check!(content_view: content_view, metadata: metadata, path: path)
+          ::Katello::Pulp3::ContentViewVersion::Import.reset_content_view_repositories_from_metadata!(content_view: content_view, metadata: metadata)
+
           major = metadata[:content_view_version][:major]
           minor = metadata[:content_view_version][:minor]
 
-          if ::Katello::ContentViewVersion.where(major: major, minor: minor, content_view: content_view).exists?
-            cvv_name = "#{content_view.name} #{major}.#{minor}"
-            fail _("Content View Version specified in the metadata - '%{name}' already exists. "\
-                    "If you wish to replace the existing version, delete %{name} and try again. " % { name: cvv_name })
-          end
-
           plan_action(::Actions::Katello::ContentView::Publish, content_view, '',
                         path: path,
-                        import_only: true,
+                        metadata: metadata,
+                        importing: true,
                         major: major,
                         minor: minor)
         end