katello 3.18.0.rc1 → 4.0.0.rc1

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/activation_key/create.rb

@@ -4,17 +4,15 @@ module Actions
       class Create < Actions::EntryAction
         def plan(activation_key, params = {})
           activation_key.save!
-          if ::SETTINGS[:katello][:use_cp]
-            cp_create = plan_action(Candlepin::ActivationKey::Create,
-                                    organization_label: activation_key.organization.label,
-                                    auto_attach: activation_key.auto_attach,
-                                    service_level: params[:service_level],
-                                    release_version: activation_key.release_version,
-                                    purpose_role: activation_key.purpose_role,
-                                    purpose_usage: activation_key.purpose_usage,
-                                    purpose_addons: activation_key.purpose_addons.pluck(:name))
-            cp_id = cp_create.output[:response][:id]
-          end
+          cp_create = plan_action(Candlepin::ActivationKey::Create,
+                                  organization_label: activation_key.organization.label,
+                                  auto_attach: activation_key.auto_attach,
+                                  service_level: params[:service_level],
+                                  release_version: activation_key.release_version,
+                                  purpose_role: activation_key.purpose_role,
+                                  purpose_usage: activation_key.purpose_usage,
+                                  purpose_addons: activation_key.purpose_addons.pluck(:name))
+          cp_id = cp_create.output[:response][:id]
           action_subject(activation_key, :cp_id => cp_id)
           plan_self
         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

@@ -30,18 +30,18 @@ module Actions
 
           fail _("Action not allowed for the default smart proxy.") if smart_proxy.pulp_primary?
 
-          smart_proxy_helper = ::Katello::SmartProxyHelper.new(smart_proxy)
-          repositories = smart_proxy_helper.combined_repos_available_to_capsule(environment, content_view, repository)
-
-          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::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?
+            if smart_proxy.has_feature?(SmartProxy::PULP_NODE_FEATURE)
+              plan_action(Actions::Pulp::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            end
+
+            if smart_proxy.has_feature?(SmartProxy::PULP3_FEATURE)
+              plan_action(Actions::Pulp3::CapsuleContent::RefreshContentGuard, smart_proxy)
+              plan_action(Actions::Pulp3::Orchestration::Repository::RefreshRepos, smart_proxy, refresh_options)
+            end
             plan_action(SyncCapsule, smart_proxy, refresh_options)
           end
         end

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,10 +19,14 @@ module Actions
                                     Actions::Pulp3::CapsuleContent::Sync],
                                      repo, smart_proxy,
                                      skip_metadata_check: skip_metadata_check)
+                end
+              end
 
+              concurrence do
+                repo_batch.each do |repo|
                   if repo.is_a?(::Katello::Repository) &&
-                    repo.distribution_bootable? &&
-                    repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+                      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)
@@ -32,24 +35,44 @@ module Actions
               end
             end
           end
+          update_unauthenticated_repo_list(smart_proxy) if smart_proxy.has_feature?("Container_Gateway")
         end
 
-        def repos_to_sync(smart_proxy, environment, content_view, repository)
+        def update_unauthenticated_repo_list(smart_proxy)
+          unauthenticated_repo_list =
+            ::Katello::SmartProxyHelper.new(smart_proxy).combined_repos_available_to_capsule.select do |repo|
+              repo.docker? && repo.environment.registry_unauthenticated_pull
+            end
+          smart_proxy.update_unauthenticated_repo_list(unauthenticated_repo_list.map(&:container_repository_name))
+        end
+
+        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/check_matching_content.rb

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module CheckMatchingContent
+      def check_matching_content(new_repository, source_repositories)
+        check_matching_content = ::Katello::RepositoryTypeManager.find(new_repository.content_type).metadata_publish_matching_check
+        if new_repository.environment && source_repositories.count == 1 && check_matching_content
+          match_check_output = plan_action(Katello::Repository::CheckMatchingContent,
+                                           :source_repo_id => source_repositories.first.id,
+                                           :target_repo_id => new_repository.id).output
+
+          return match_check_output[:matching_content]
+        end
+        false
+      end
+    end
+  end
+end

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

@@ -4,14 +4,12 @@ module Actions
       class EnvironmentCreate < Actions::Base
         def plan(content_view_environment)
           content_view_environment.save!
-          if ::SETTINGS[:katello][:use_cp]
-            content_view = content_view_environment.content_view
-            plan_action(Candlepin::Environment::Create,
-                        organization_label: content_view.organization.label,
-                        cp_id:              content_view_environment.cp_id,
-                        name:               content_view_environment.label,
-                        description:        content_view.description)
-          end
+          content_view = content_view_environment.content_view
+          plan_action(Candlepin::Environment::Create,
+                      organization_label: content_view.organization.label,
+                      cp_id:              content_view_environment.cp_id,
+                      name:               content_view_environment.label,
+                      description:        content_view.description)
         end
 
         def humanized_name

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,10 +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}) # rubocop:disable Metrics/PerceivedComplexity
           action_subject(content_view)
-          import_only = options.fetch(:import_only, false)
-          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)
@@ -52,7 +52,8 @@ 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
+
+              if options[:importing]
                 handle_import(version, options.slice(:path, :metadata))
               else
                 plan_action(Repository::MultiCloneToVersion, separated_repo_map[:pulp3_yum], version)
@@ -136,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)

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

@@ -2,28 +2,22 @@ module Actions
   module Katello
     module ContentViewVersion
       class Import < Actions::EntryAction
-        PULP_USER = 'pulp'.freeze
-
         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 ::Katello::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)
+
+          ::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,
                         metadata: metadata,
-                        import_only: true,
+                        importing: true,
                         major: major,
                         minor: minor)
         end

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

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class ImportLibrary < Actions::EntryAction
+        def plan(organization, path:, metadata:)
+          action_subject(organization)
+          library_view = ::Katello::Pulp3::ContentViewVersion::Import.find_or_create_library_import_view(organization)
+          plan_action(::Actions::Katello::ContentViewVersion::Import, library_view, path: path, metadata: metadata)
+        end
+
+        def humanized_name
+          _("Import Default Content View")
+        end
+      end
+    end
+  end
+end

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

@@ -19,7 +19,7 @@ module Actions
 
         # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/AbcSize
-        def plan(old_version, environments, options = {})
+        def plan(old_version, environments, options = {}) # rubocop:disable Metrics/CyclomaticComplexity
           dep_solve = options.fetch(:resolve_dependencies, true)
           description = options.fetch(:description, '')
           content = options.fetch(:content, {})
@@ -88,11 +88,15 @@ module Actions
                 end
               end
 
-              sequence do
-                new_puppet_environment = plan_action(Katello::ContentViewPuppetEnvironment::Clone, old_version,
-                                                   :new_version => new_content_view_version).new_puppet_environment
-                check_puppet_module_duplicates(content[:puppet_module_ids])
-                copy_action_outputs += copy_puppet_content(new_puppet_environment, content[:puppet_module_ids], old_version) unless content[:puppet_module_ids].blank?
+              if SmartProxy.pulp_primary.has_feature?(SmartProxy::PULP_FEATURE) && SETTINGS[:katello][:content_types][:puppet]
+                sequence do
+                  new_puppet_environment = plan_action(Katello::ContentViewPuppetEnvironment::Clone, old_version,
+                                                     :new_version => new_content_view_version).new_puppet_environment
+                  check_puppet_module_duplicates(content[:puppet_module_ids])
+                  unless content[:puppet_module_ids].blank?
+                    copy_action_outputs += copy_puppet_content(new_puppet_environment, content[:puppet_module_ids], old_version)
+                  end
+                end
               end
             end
 
@@ -201,7 +205,7 @@ module Actions
           end
         end
 
-        def run
+        def run # rubocop:disable Metrics/CyclomaticComplexity
           content = { ::Katello::Erratum::CONTENT_TYPE => [],
                       ::Katello::Rpm::CONTENT_TYPE => [],
                       ::Katello::ModuleStream::CONTENT_TYPE => [],
@@ -352,20 +356,36 @@ module Actions
         end
 
         def copy_yum_content(new_repo, dep_solve, package_ids, errata_ids)
+          return [] unless new_repo.content_type == ::Katello::Repository::YUM_TYPE
+
           copy_outputs = []
-          if new_repo.content_type == ::Katello::Repository::YUM_TYPE
-            unless errata_ids.blank?
+
+          unless errata_ids.blank?
+            content_present_in_this_repo = new_repo
+                                            .library_instance
+                                            .errata
+                                            .with_identifiers(errata_ids)
+                                            .exists?
+            if content_present_in_this_repo
               copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
                                           ::Katello::Erratum.with_identifiers(errata_ids),
                                           incremental_update: dep_solve).output
             end
+          end
 
-            unless package_ids.blank?
+          unless package_ids.blank?
+            content_present_in_this_repo = new_repo
+                                            .library_instance
+                                            .rpms
+                                            .with_identifiers(package_ids)
+                                            .exists?
+            if content_present_in_this_repo
               copy_outputs << plan_action(Pulp::Repository::CopyUnits, new_repo.library_instance, new_repo,
                                           ::Katello::Rpm.with_identifiers(package_ids),
                                           incremental_update: dep_solve).output
             end
           end
+
           copy_outputs
         end
 

data/app/lib/actions/katello/host/hypervisors_update.rb

@@ -54,10 +54,10 @@ module Actions
 
         # Loads all resources needed for refreshing subscription facet
         def load_resources
-          @organizations = ::Organization.where(label: hypervisors_field(:organization_label)).map { |org| [org.label, org] }.to_h
+          @organizations = ::Organization.where(label: hypervisors_field(:organization_label)).index_by { |org| org.label }
 
           candlepin_data = ::Katello::Resources::Candlepin::Consumer.get_all_with_facts(hypervisors_field(:uuid))
-          @candlepin_attributes = candlepin_data.map { |consumer| [consumer[:uuid], consumer] }.to_h
+          @candlepin_attributes = candlepin_data.index_by { |consumer| consumer[:uuid] }
 
           @hosts = {}
           @hosts.merge!(load_hosts_by_uuid)
@@ -70,7 +70,7 @@ module Actions
           hosts_by_uuid.each do |host|
             validate_host_organization(host, host.organization.try(:id))
           end
-          hosts_by_uuid.map { |host| [host.subscription_facet.uuid, host] }.to_h
+          hosts_by_uuid.index_by { |host| host.subscription_facet.uuid }
         end
 
         def load_hosts_by_duplicate_name
@@ -82,7 +82,7 @@ module Actions
             validate_host_organization(host, duplicate_name_orgs[host.name].try(:id))
           end
 
-          hosts_by_dup_name.map { |host| [duplicate_names[host.name], host] }.to_h
+          hosts_by_dup_name.index_by { |host| duplicate_names[host.name] }
         end
 
         def create_missing_hosts

data/app/lib/actions/katello/host/update_system_purpose.rb

@@ -14,7 +14,7 @@ module Actions
             host.subscription_facet.purpose_addons = purpose_addon_objects
           end
 
-          host.subscription_facet.save!
+          host.save!
           plan_self(:hostname => host.name)
         end
 

data/app/lib/actions/katello/host/upload_package_profile.rb

@@ -39,7 +39,9 @@ module Actions
             Rails.logger.warn("Host with ID %s has no content facet, continuing" % host_id)
           else
             begin
-              ::Katello::Pulp::Consumer.new(host.content_facet.uuid).upload_package_profile(profile)
+              if SmartProxy.pulp_primary&.has_feature?(SmartProxy::PULP_FEATURE)
+                ::Katello::Pulp::Consumer.new(host.content_facet.uuid).upload_package_profile(profile)
+              end
               simple_packages = profile.map { |item| ::Katello::Pulp::SimplePackage.new(item) }
               host.import_package_profile(simple_packages)
             rescue RestClient::ResourceNotFound

data/app/lib/actions/katello/host/upload_profiles.rb

@@ -60,12 +60,14 @@ module Actions
 
           module_stream_profile = updated_profiles + unassociated_profiles
 
-          unless module_stream_profile.empty?
-            begin
-              ::Katello::Pulp::Consumer.new(host.content_facet.uuid).
-                upload_module_stream_profile(module_stream_profile)
-            rescue RestClient::ResourceNotFound
-              Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % host.id)
+          if SmartProxy.pulp_primary&.has_feature?(SmartProxy::PULP_FEATURE)
+            unless module_stream_profile.empty?
+              begin
+                ::Katello::Pulp::Consumer.new(host.content_facet.uuid).
+                  upload_module_stream_profile(module_stream_profile)
+              rescue RestClient::ResourceNotFound
+                Rails.logger.warn("Host with ID %s was not known to Pulp, continuing" % host.id)
+              end
             end
           end
         end