katello 3.13.4 → 3.14.0.rc1

data/app/lib/actions/pulp3/orchestration/repository/copy_all_units.rb

@@ -13,27 +13,27 @@ module Actions
             if filter_ids.present? || rpm_filenames.present? || source_repositories.length > 1
               sequence do
                 if filter_ids.present? || rpm_filenames.present?
-                  #if we are filtering, we need to copy from each repo with filters in place.  We also need to clear out everything in the repo
-                  # which will be easier with https://pulp.plan.io/issues/4901
-                  start_copying_from = 0
-                  fail "Publish with filters are not currently supported"
+                  copy_action = plan_action(Actions::Pulp3::Repository::CopyContent,
+                                            source_repositories.first, smart_proxy, target_repo,
+                                            filter_ids: filter_ids, solve_dependencies: solve_dependencies,
+                                            rpm_filenames: rpm_filenames)
+
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, copy_action.output[:pulp_tasks])
                 else
                   #if we are not filtering, copy the version to the cv repository, and the units for each additional repo
                   action = plan_action(Actions::Pulp3::Repository::CopyVersion, source_repositories.first, smart_proxy, target_repo)
                   plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, action.output[:pulp_tasks])
-                  start_copying_from = 1 #since we're creating a new version from the first repo, start copying at the 2nd
-                end
+                  copy_actions = []
+                  #since we're creating a new version from the first repo, start copying at the 2nd
+                  source_repositories[1..-1].each do |source_repo|
+                    copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent,
+                                                source_repo, smart_proxy, target_repo,
+                                                filter_ids: filter_ids, solve_dependencies: solve_dependencies,
+                                                rpm_filenames: rpm_filenames)
+                  end
 
-                copy_actions = []
-                source_repositories[start_copying_from..-1].each do |source_repo|
-                  copy_actions << plan_action(Actions::Pulp3::Repository::CopyContent,
-                                              source_repo, smart_proxy, target_repo,
-                                              filter_ids: filter_ids,
-                                              solve_dependencies: solve_dependencies,
-                                              rpm_filenames: rpm_filenames)
+                  plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, copy_actions.last.output[:pulp_tasks])
                 end
-
-                plan_action(Actions::Pulp3::Repository::SaveVersion, target_repo, copy_actions.last.output[:pulp_tasks])
               end
             else
               plan_self(source_version_repo_id: source_repositories.first.id,

data/app/lib/actions/pulp3/orchestration/repository/create.rb

@@ -6,7 +6,9 @@ module Actions
           def plan(repository, smart_proxy)
             sequence do
               plan_action(Actions::Pulp3::Repository::Create, repository, smart_proxy)
-              plan_action(Actions::Pulp3::Repository::CreateRemote, repository, smart_proxy) if repository.content_view.default?
+              if repository.content_view.default? || !smart_proxy.pulp_master?
+                plan_action(Actions::Pulp3::Repository::CreateRemote, repository, smart_proxy)
+              end
             end
           end
         end

data/app/lib/actions/pulp3/orchestration/repository/import_upload.rb

@@ -0,0 +1,36 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module Repository
+        class ImportUpload < Pulp3::AbstractAsyncTask
+          def plan(repository, smart_proxy, args)
+            file = {:filename => args.dig(:unit_key, :name)}
+            content_unit_href = args.dig(:unit_key, :content_unit_id)
+            sequence do
+              if !content_unit_href
+                action_output = plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :upload_href => "/pulp/api/v3/uploads/" + args.dig(:upload_id) + "/", :sha256 => args.dig(:unit_key, :checksum)).output
+                artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, action_output[:pulp_tasks], args.dig(:unit_type_id)).output
+                content_unit_href = artifact_action_output[:pulp_tasks]
+              else
+                plan_self(:skip => true)
+              end
+              action_output = plan_action(Pulp3::Repository::ImportUpload, content_unit_href, repository, smart_proxy).output
+              plan_action(Pulp3::Repository::SaveVersion, repository, action_output[:pulp_tasks]).output
+            end
+          end
+
+          def invoke_external_task
+            if input[:skip]
+              output[:pulp_tasks] = nil
+            else
+              repo = ::Katello::Repository.find(input[:repository_id])
+              repo_backend_service = repo.backend_service(smart_proxy)
+              uploads_api = repo_backend_service.uploads_api
+              output[:pulp_tasks] = [uploads_api.commit(input[:upload_href], sha256: input[:sha256])]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/repository/refresh_repos.rb

@@ -0,0 +1,24 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module Repository
+        class RefreshRepos < Pulp3::AbstractAsyncTask
+          include ::Actions::Katello::CapsuleContent::RefreshRepos
+          input_format do
+            param :smart_proxy_id
+            param :environment_id
+            param :content_view_id
+            param :repository_id
+          end
+          def fetch_proxy_service(smart_proxy)
+            ::Katello::Pulp3::SmartProxyRepository.new(smart_proxy)
+          end
+
+          def act_on_repo?(repo, smart_proxy)
+            smart_proxy.pulp3_support?(repo)
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orchestration/repository/sync.rb

@@ -8,7 +8,7 @@ module Actions
             sequence do
               action_output = plan_action(Actions::Pulp3::Repository::Sync, repository, smart_proxy, options).output
               version_output = plan_action(Pulp3::Repository::SaveVersion, repository, action_output[:pulp_tasks]).output
-              plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :force => true, :contents_changed => version_output[:contents_changed])
+              plan_action(Pulp3::Orchestration::Repository::GenerateMetadata, repository, smart_proxy, :contents_changed => version_output[:contents_changed])
               plan_self(:subaction_output => version_output)
             end
           end

data/app/lib/actions/pulp3/orchestration/repository/upload_content.rb

@@ -0,0 +1,25 @@
+module Actions
+  module Pulp3
+    module Orchestration
+      module Repository
+        class UploadContent < Pulp3::Abstract
+          def plan(repository, smart_proxy, file, unit_type_id)
+            sequence do
+              content_backend_service = SmartProxy.pulp_master.content_service(unit_type_id)
+              content_list = content_backend_service.content_api.list("digest": Digest::SHA256.hexdigest(File.read(file[:path])))
+              if content_list.results.empty?
+                upload_action_output = plan_action(Pulp3::Repository::UploadFile, repository, smart_proxy, file[:path]).output
+                artifact_action_output = plan_action(Pulp3::Repository::SaveArtifact, file, repository, smart_proxy, upload_action_output[:pulp_tasks], unit_type_id).output
+                content_unit_href = artifact_action_output[:pulp_tasks]
+              else
+                content_unit_href = content_list.results.first.pulp_href
+              end
+              action_output = plan_action(Pulp3::Repository::ImportUpload, content_unit_href, repository, smart_proxy).output
+              plan_action(Pulp3::Repository::SaveVersion, repository, action_output[:pulp_tasks]).output
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orphan_cleanup/delete_orphan_repository_versions.rb

@@ -0,0 +1,20 @@
+module Actions
+  module Pulp3
+    module OrphanCleanup
+      class DeleteOrphanRepositoryVersions < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy)
+          plan_self(:smart_proxy_id => smart_proxy.id)
+        end
+
+        def run
+          smart_proxy = SmartProxy.find(input[:smart_proxy_id])
+          if smart_proxy.pulp_mirror?
+            output[:pulp_tasks] = ::Katello::Pulp3::Repository.delete_orphan_repository_versions_for_mirror(smart_proxy)
+          else
+            output[:pulp_tasks] = ::Katello::Pulp3::Repository.delete_orphan_repository_versions(smart_proxy)
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/orphan_cleanup/remove_unneeded_repos.rb

@@ -0,0 +1,16 @@
+module Actions
+  module Pulp3
+    module OrphanCleanup
+      class RemoveUnneededRepos < Pulp3::AbstractAsyncTask
+        def plan(smart_proxy)
+          plan_self(:smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          smart_proxy_service = ::Katello::Pulp3::SmartProxyRepository.new(smart_proxy)
+          smart_proxy_service.delete_orphaned_repositories_for_mirror_proxies
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/create_publication.rb

@@ -12,11 +12,7 @@ module Actions
 
         def invoke_external_task
           repository = ::Katello::Repository.find(input[:repository_id])
-          if repository.publication_href.nil? || input[:options][:force]
-            output[:response] = repository.backend_service(smart_proxy).create_publication
-          else
-            []
-          end
+          output[:response] = repository.backend_service(smart_proxy).create_publication
         end
       end
     end

data/app/lib/actions/pulp3/repository/import_upload.rb

@@ -0,0 +1,21 @@
+# This action takes a content unit and a repository
+# Creates a content unit based on content type and then creates a new repository version with the added content.
+module Actions
+  module Pulp3
+    module Repository
+      class ImportUpload < Pulp3::AbstractAsyncTask
+        def plan(content_unit, repository, smart_proxy)
+          plan_self(:content_unit => content_unit, :repository_id => repository.id, :smart_proxy_id => smart_proxy.id)
+        end
+
+        def invoke_external_task
+          content_unit = input[:content_unit]
+          content_unit_href = content_unit.is_a?(String) ? content_unit : content_unit.last[:created_resources].first
+          repo = ::Katello::Repository.find(input[:repository_id])
+          repo_backend_service = repo.backend_service(smart_proxy)
+          output[:pulp_tasks] = repo_backend_service.add_content(content_unit_href)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/save_artifact.rb

@@ -0,0 +1,19 @@
+module Actions
+  module Pulp3
+    module Repository
+      class SaveArtifact < Pulp3::AbstractAsyncTask
+        def plan(file, repository, smart_proxy, tasks, unit_type_id, options = {})
+          options[:file_name] = file[:filename]
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :tasks => tasks, :unit_type_id => unit_type_id, :options => options)
+        end
+
+        def invoke_external_task
+          artifact_href = input[:tasks].last[:created_resources].first
+          content_type = input[:unit_type_id]
+          content_backend_service = SmartProxy.pulp_master.content_service(content_type)
+          output[:pulp_tasks] = [content_backend_service.content_api.create(input[:options][:file_name], artifact: artifact_href)]
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/pulp3/repository/save_version.rb

@@ -10,9 +10,10 @@ module Actions
           version_href = input[:tasks].last[:created_resources].first
           repo = ::Katello::Repository.find(input[:repository_id])
           repo_version = repo.backend_service(::SmartProxy.pulp_master).lookup_version version_href
-          content_summary = send(:eval, repo_version.content_summary)
+
+          content_summary = repo_version.content_summary
           first_version = (repo_version.number == 1)
-          output[:contents_changed] = first_version || !(content_summary.dig(:added).empty? && content_summary.dig(:removed).empty?)
+          output[:contents_changed] = first_version || !(content_summary.added.empty? && content_summary.removed.empty?)
           if version_href && output[:contents_changed]
             repo.update_attributes(:version_href => version_href)
           end

data/app/lib/actions/pulp3/repository/sync.rb

@@ -10,7 +10,7 @@ module Actions
 
         def invoke_external_task
           repo = ::Katello::Repository.find(input[:repo_id])
-          output[:pulp_tasks] = repo.backend_service(::SmartProxy.find(input[:smart_proxy_id])).sync
+          output[:pulp_tasks] = repo.backend_service(::SmartProxy.unscoped.find(input[:smart_proxy_id])).sync
         end
 
         def external_task=(tasks)

data/app/lib/actions/pulp3/repository/upload_file.rb

@@ -0,0 +1,76 @@
+module Actions
+  module Pulp3
+    module Repository
+      class UploadFile < Pulp3::AbstractAsyncTask
+        def plan(repository, smart_proxy, file)
+          plan_self(:repository_id => repository.id, :smart_proxy_id => smart_proxy.id, :file => file)
+        end
+
+        def invoke_external_task
+          repo = ::Katello::Repository.find(input[:repository_id])
+          repo_backend_service = repo.backend_service(smart_proxy)
+          upload_class = repo_backend_service.upload_class
+          uploads_api = repo_backend_service.uploads_api
+          offset = 0
+          response = nil
+          File.open(input[:file], "rb") do |file|
+            total_size = File.size(file)
+            upload_href = uploads_api.create(upload_class.new(size: total_size)).pulp_href
+            sha256 = Digest::SHA256.hexdigest(File.read(file))
+            until file.eof?
+              chunk = file.read(upload_chunk_size)
+              begin
+                filechunk = Tempfile.new('filechunk', :encoding => 'ascii-8bit')
+                filechunk.write(chunk)
+                filechunk.flush
+                actual_chunk_size = File.size(filechunk)
+                response = uploads_api.update(upload_href, content_range(offset, offset + actual_chunk_size - 1, total_size), filechunk)
+                offset += actual_chunk_size - 1
+              ensure
+                filechunk.close
+                filechunk.unlink
+              end
+            end
+
+            if response
+              upload_href = response.pulp_href
+              output[:pulp_tasks] = [uploads_api.commit(upload_href, sha256: sha256)]
+            end
+          end
+        end
+
+        def external_task=(tasks)
+          super
+        end
+
+        def finalize
+          check_error_details
+        end
+
+        def check_error_details
+          output[:pulp_tasks].each do |pulp_task|
+            error_details = pulp_task.try(:[], "error")
+            if error_details && !error_details.nil?
+              fail _("An error occurred during the sync \n%{error_message}") % {:error_message => error_details}
+            end
+          end
+        end
+
+        private
+
+        def upload_chunk_size
+          SETTINGS[:katello][:pulp][:upload_chunk_size]
+        end
+
+        def checksum(file)
+          Digest::SHA256.hexdigest(File.read(file))
+        end
+
+        def content_range(start, finish, total)
+          finish = finish > total ? total : finish
+          "bytes #{start}-#{finish}/#{total}"
+        end
+      end
+    end
+  end
+end

data/app/lib/katello/api/v2/rendering.rb

@@ -43,8 +43,7 @@ module Katello
 
           render :template => "katello/api/v2/#{resource_name}/#{action}",
                  :status => status,
-                 :locals => { :object_name => options[:object_name],
-                              :root_name => options[:root_name] },
+                 :locals => options.slice(:object_name, :root_name, :locals),
                  :layout => "katello/api/v2/layouts/#{options[:layout]}"
         end
 

data/app/lib/katello/concerns/base_template_scope_extensions.rb

@@ -6,7 +6,8 @@ module Katello
       module Overrides
         def allowed_helpers
           super + [:errata, :host_subscriptions, :host_applicable_errata_ids, :host_applicable_errata_filtered,
-                   :host_latest_applicable_rpm_version, :load_pools, :load_errata_applications]
+                   :host_latest_applicable_rpm_version, :load_pools, :load_errata_applications, :host_content_facet,
+                   :host_sla, :host_products, :sub_name, :sub_sku, :registered_through]
         end
       end
 
@@ -22,6 +23,32 @@ module Katello
         host.subscriptions
       end
 
+      def host_content_facet(host)
+        host.content_facet
+      end
+
+      def host_sla(host)
+        host_subscription_facet(host)&.service_level
+      end
+
+      def host_products(host)
+        host_subscription_facet(host)&.installed_products
+      end
+
+      def sub_name(pool)
+        return unless pool
+        pool.subscription&.name
+      end
+
+      def sub_sku(pool)
+        return unless pool
+        pool.subscription&.cp_id
+      end
+
+      def registered_through(host)
+        host_subscription_facet(host)&.registered_through
+      end
+
       def host_applicable_errata_ids(host)
         host.applicable_errata.map(&:errata_id)
       end
@@ -39,9 +66,10 @@ module Katello
       end
 
       # rubocop:disable Metrics/MethodLength
-      def load_errata_applications(filter_errata_type: 'all', include_last_reboot: 'yes', since: nil, up_to: nil, status: nil)
+      def load_errata_applications(filter_errata_type: nil, include_last_reboot: 'yes', since: nil, up_to: nil, status: nil)
         result = []
 
+        filter_errata_type = filter_errata_type.presence || 'all'
         search_up_to = up_to.present? ? "ended_at < \"#{up_to}\"" : nil
         search_since = since.present? ? "ended_at > \"#{since}\"" : nil
         search_result = status.present? ? "result = #{status}" : nil
@@ -107,6 +135,10 @@ module Katello
 
       private
 
+      def host_subscription_facet(host)
+        host.subscription_facet
+      end
+
       def parse_errata(task)
         @_tasks_errata_cache[task.id] ||= if task.input['errata'].present?
                                             # katello agent errata

data/app/lib/katello/errors.rb

@@ -100,6 +100,21 @@ module Katello
       end
     end
 
+    class Pulp3Error < StandardError
+      def self.from_task(task)
+        if task[:state] == 'canceled'
+          self.new(_("Task canceled"))
+        elsif task[:state] == 'failed'
+          message = if task[:error][:description].blank?
+                      _("Pulp task error")
+                    else
+                      task[:error][:description]
+                    end
+          self.new(message)
+        end
+      end
+    end
+
     class PulpError < StandardError
       def self.from_task(task)
         if %w(error canceled).include?(task[:state])
@@ -125,5 +140,11 @@ module Katello
     end
 
     class UpstreamEntitlementGone < StandardError; end
+
+    class ContainerRegistryNotConfigured < StandardError
+      def message
+        _("No URL found for a container registry. Please check the configuration.")
+      end
+    end
   end
 end