katello 3.12.3 → 3.13.0.rc1

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

@@ -2,6 +2,7 @@ module Actions
   module Katello
     module Repository
       class Destroy < Actions::EntryAction
+        include Actions::Katello::PulpSelector
         middleware.use ::Actions::Middleware::RemoteAction
 
         # options:
@@ -18,10 +19,10 @@ module Actions
           end
 
           plan_action(ContentViewPuppetModule::Destroy, repository) if repository.puppet?
-          plan_action(PulpSelector,
-            [Actions::Pulp::Orchestration::Repository::Delete,
-             Actions::Pulp3::Orchestration::Repository::Delete],
-            repository, SmartProxy.pulp_master)
+          plan_pulp_action([Actions::Pulp::Orchestration::Repository::Delete,
+                            Actions::Pulp3::Orchestration::Repository::Delete],
+                           repository,
+                           SmartProxy.pulp_master)
 
           plan_self(:user_id => ::User.current.id)
           sequence do

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

@@ -51,16 +51,16 @@ module Actions
         end
 
         def proxy
-          proxy = {}
-
-          if (config = SETTINGS[:katello][:cdn_proxy])
-            proxy[:proxy_host] = URI.parse(config[:host]).host if config.key?(:host)
-            proxy[:proxy_port] = config[:port] if config.key?(:port)
-            proxy[:proxy_user] = config[:user] if config.key?(:user)
-            proxy[:proxy_password] = config[:password] if config.key?(:password)
+          proxy_details = {}
+          if (proxy = ::HttpProxy.default_global_content_proxy)
+            uri = URI(proxy.url)
+            proxy_details[:proxy_host] = "#{uri.host}#{uri.path}"
+            proxy_details[:proxy_port] = uri.port
+            proxy_details[:proxy_user] = proxy.username
+            proxy_details[:proxy_password] = proxy.password
           end
 
-          proxy
+          proxy_details
         end
       end
     end

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

@@ -68,7 +68,7 @@ module Actions
             repos.each do |repo|
               sequence do
                 if repo.link?
-                  plan_action(Katello::Repository::Clear, repo)
+                  plan_action(Pulp::Repository::Clear, repo, SmartProxy.pulp_master!)
                   plan_action(Pulp::Repository::CopyAllUnits, repo.target_repository, repo)
                 end
               end

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

@@ -6,11 +6,11 @@ module Actions
           param :id, Integer
           param :filter
           param :dependency
+          param :content_type
         end
 
         def run
           repo = ::Katello::Repository.find(input[:id])
-          unit_ids = search_units(repo)
           if repo.puppet?
             ::Katello::PuppetModule.import_for_repository(repo)
           elsif repo.docker?
@@ -20,16 +20,21 @@ module Actions
           elsif repo.file?
             ::Katello::FileUnit.import_for_repository(repo)
           elsif repo.deb?
-            ::Katello::Deb.import_all(unit_ids)
-          else
-            ::Katello::Rpm.import_all(unit_ids)
+            ::Katello::Deb.import_all(unit_ids, repo)
+          elsif repo.yum?
+            unit_ids = search_units(repo)
+            if input[:content_type] == 'srpm'
+              ::Katello::Srpm.import_all(unit_ids, repo)
+            else
+              ::Katello::Rpm.import_all(unit_ids, repo)
+            end
           end
         end
 
         private
 
         def search_units(repo)
-          found = repo.unit_search(:type_ids => [repo.unit_type_id],
+          found = repo.unit_search(:type_ids => [input[:content_type]],
                                    :filters => input[:filter])
           found.map { |result| result.try(:[], :unit_id) }.compact
         end

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

@@ -4,6 +4,13 @@ module Actions
       class FinishUpload < Actions::Base
         def plan(repository, options = {})
           dependency = options.fetch(:dependency, nil)
+          content_type = options.fetch(:content_type)
+          if content_type
+            unit_type_id = SmartProxy.pulp_master.content_service(content_type)::CONTENT_TYPE
+          else
+            content_type = repository.content_type
+            unit_type_id = SmartProxy.pulp_master.content_service(content_type)::CONTENT_TYPE
+          end
           generate_metadata = options.fetch(:generate_metadata, true)
           plan_action(Katello::Repository::MetadataGenerate, repository, :dependency => dependency) if generate_metadata
 
@@ -11,6 +18,7 @@ module Actions
           plan_action(Katello::Repository::FilteredIndexContent,
                       id: repository.id,
                       filter: {:association => {:created => {"$gt" => recent_range}}},
+                      content_type: unit_type_id,
                       dependency: dependency)
         end
       end

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

@@ -11,7 +11,10 @@ module Actions
           unit_keys = repo_service.unit_keys(uploads)
           generate_metadata = options.fetch(:generate_metadata, true)
           sync_capsule = options.fetch(:sync_capsule, true)
-          unit_type_id = repo_service.unit_type_id(uploads)
+          repo_type = repository.content_type
+
+          options[:content_type] ||= ::Katello::RepositoryTypeManager.find(repo_type).default_managed_content_type.label
+          unit_type_id = SmartProxy.pulp_master.content_service(options[:content_type])::CONTENT_TYPE
 
           sequence do
             upload_results = concurrence do
@@ -27,7 +30,7 @@ module Actions
                                             unit_metadata: unit_metadata)
 
                 plan_action(FinishUpload, repository, :dependency => import_upload.output,
-                            generate_metadata: false)
+                            generate_metadata: false, content_type: options[:content_type])
                 import_upload.output
               end
             end

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

@@ -8,12 +8,13 @@ module Actions
           param :id, Integer
           param :dependency, Hash
           param :contents_changed
-          param :full_index
+          param :source_repository_id
         end
 
         def run
+          source_repository = ::Katello::Repository.find(input[:source_repository_id]) if input[:source_repository_id]
           repo = ::Katello::Repository.find(input[:id])
-          repo.index_content(input[:full_index])
+          repo.index_content(source_repository: source_repository)
         end
       end
     end

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

@@ -2,19 +2,25 @@ module Actions
   module Katello
     module Repository
       class MetadataGenerate < Actions::Base
+        include Actions::Katello::PulpSelector
+
         def plan(repository, options = {})
           dependency = options.fetch(:dependency, nil)
           force = options.fetch(:force, false)
           repository_creation = options.fetch(:repository_creation, false)
           source_repository = options.fetch(:source_repository, nil)
           source_repository ||= repository.target_repository if repository.link?
+          if repository_creation
+            matching_content = false
+          else
+            matching_content = options.fetch(:matching_content, false)
+          end
 
-          plan_action(PulpSelector,
-                      [Pulp::Repository::DistributorPublish, Pulp3::Orchestration::Repository::GenerateMetadata],
-                      repository, SmartProxy.pulp_master,
+          plan_pulp_action([Pulp::Repository::DistributorPublish, Pulp3::Orchestration::Repository::GenerateMetadata],
+                        repository, SmartProxy.pulp_master,
                         :force => force,
                         :source_repository => source_repository,
-                        :matching_content => options[:matching_content],
+                        :matching_content => matching_content,
                         :dependency => dependency,
                         :repository_creation => repository_creation)
         end

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

@@ -3,6 +3,7 @@ module Actions
     module Repository
       class RemoveContent < Actions::EntryAction
         include Dynflow::Action::WithSubPlans
+        include Actions::Katello::PulpSelector
 
         def plan(repository, content_units, options = {})
           sync_capsule = options.fetch(:sync_capsule, true)
@@ -15,12 +16,19 @@ module Actions
 
           action_subject(repository)
 
-          pulp_action = Pulp::Repository::RemoveUnits
           content_unit_ids = content_units.map(&:id)
-          content_unit_type = content_units.first.class::CONTENT_TYPE
+          content_unit_type = options[:content_type] || content_units.first.class::CONTENT_TYPE
 
           sequence do
-            plan_action(pulp_action, :repo_id => repository.id, :contents => content_unit_ids, :content_unit_type => content_unit_type)
+            remove_content_args = {
+              :contents => content_unit_ids,
+              :content_unit_type => content_unit_type}
+
+            pulp_action = plan_pulp_action(
+              [Pulp::Orchestration::Repository::RemoveUnits,
+               Pulp3::Orchestration::Repository::RemoveUnits],
+              repository, SmartProxy.pulp_master, remove_content_args)
+            return if pulp_action.error
             plan_self(:content_unit_class => content_units.first.class.name, :content_unit_ids => content_unit_ids)
             plan_action(CapsuleSync, repository) if sync_capsule
           end

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

@@ -4,6 +4,7 @@ module Actions
     module Repository
       class Sync < Actions::EntryAction
         include Helpers::Presenter
+        include Actions::Katello::PulpSelector
         middleware.use Actions::Middleware::ExecuteIfContentsChanged
 
         input_format do
@@ -16,7 +17,7 @@ module Actions
         #   of Katello and we just need to finish the rest of the orchestration
         # rubocop:disable MethodLength
         # rubocop:disable CyclomaticComplexity
-        def plan(repo, pulp_sync_task_id = nil, options = {})
+        def plan(repo, _pulp_sync_task_id = nil, options = {})
           action_subject(repo)
 
           source_url = options.fetch(:source_url, nil)
@@ -35,14 +36,18 @@ module Actions
           fail ::Katello::Errors::InvalidActionOptionError, _("Cannot skip metadata check on non-yum repositories.") if skip_metadata_check && !repo.yum?
 
           sequence do
-            # clear yum metadata if validate_contents is on (to avoid metadata corruption issues)
             plan_action(Pulp::Repository::RemoveUnits, :repo_id => repo.id, :content_unit_type => ::Katello::YumMetadataFile::CONTENT_TYPE) if validate_contents
-
-            sync_args = {:pulp_id => repo.pulp_id, :task_id => pulp_sync_task_id, :source_url => source_url, :options => pulp_sync_options}
-            output = plan_action(Pulp::Repository::Sync, sync_args).output
+            sync_args = {:smart_proxy_id => SmartProxy.pulp_master.id, :repo_id => repo.id, :source_url => source_url, :options => pulp_sync_options}
+            sync_action = plan_pulp_action([Actions::Pulp::Orchestration::Repository::Sync,
+                                            Actions::Pulp3::Orchestration::Repository::Sync],
+                                           repo,
+                                           SmartProxy.pulp_master,
+                                           sync_args)
+            output = sync_action.output
 
             contents_changed = skip_metadata_check || output[:contents_changed]
-            plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed, :full_index => skip_metadata_check)
+
+            plan_action(Katello::Repository::IndexContent, :id => repo.id, :contents_changed => contents_changed)
             plan_action(Katello::Foreman::ContentUpdate, repo.environment, repo.content_view, repo)
             plan_action(Katello::Repository::FetchPxeFiles, :id => repo.id)
             plan_action(Katello::Repository::CorrectChecksum, repo)
@@ -75,7 +80,9 @@ module Actions
         end
 
         def presenter
-          Helpers::Presenter::Delegated.new(self, planned_actions(Pulp::Repository::Sync))
+          found = all_planned_actions(Pulp::Repository::Sync)
+          found = all_planned_actions(Pulp3::Repository::Sync) if found.empty?
+          Helpers::Presenter::Delegated.new(self, found)
         end
 
         def pulp_task_id

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

@@ -2,6 +2,8 @@ module Actions
   module Katello
     module Repository
       class Update < Actions::EntryAction
+        include Actions::Katello::PulpSelector
+
         def plan(root, repo_params)
           repository = root.library_instance
           action_subject root.library_instance
@@ -15,22 +17,26 @@ module Actions
             plan_action(::Actions::Candlepin::Product::ContentUpdate,
                         :owner => repository.organization.label,
                         :content_id => root.content_id,
-                        :name => content.name,
+                        :name => root.name,
                         :content_url => root.custom_content_path,
                         :gpg_key_url => repository.yum_gpg_key_url,
                         :label => content.label,
                         :type => root.content_type,
                         :arches => root.arch == "noarch" ? nil : root.arch)
 
-            content.update_attributes!(name: content.name,
+            content.update_attributes!(name: root.name,
                                        content_url: root.custom_content_path,
                                        content_type: repository.content_type,
                                        label: content.label,
                                        gpg_url: repository.yum_gpg_key_url)
           end
-
-          plan_action(::Actions::Pulp::Repository::Refresh, repository) if root.pulp_update_needed?
-          plan_self(:repository_id => root.library_instance.id)
+          if root.pulp_update_needed?
+            plan_pulp_action([::Actions::Pulp::Orchestration::Repository::Refresh,
+                              ::Actions::Pulp3::Orchestration::Repository::Update],
+                             repository,
+                             SmartProxy.pulp_master)
+            plan_self(:repository_id => root.library_instance.id)
+          end
         end
 
         def run

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

@@ -0,0 +1,17 @@
+module Actions
+  module Katello
+    module Repository
+      class UpdateHttpProxyDetails < Actions::EntryAction
+        include Actions::Katello::PulpSelector
+
+        def plan(repository)
+          plan_pulp_action(
+            [Actions::Pulp::Orchestration::Repository::Refresh,
+             Actions::Pulp3::Repository::UpdateRemote],
+            repository,
+            SmartProxy.pulp_master)
+        end
+      end
+    end
+  end
+end

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

@@ -6,9 +6,13 @@ module Actions
   module Katello
     module Repository
       class UploadFiles < Actions::EntryAction
-        def plan(repository, files)
+        def plan(repository, files, content_type = nil)
           action_subject(repository)
           tmp_files = prepare_tmp_files(files)
+
+          content_type ||= ::Katello::RepositoryTypeManager.find(repository.content_type).default_managed_content_type.label
+          unit_type_id = SmartProxy.pulp_master.content_service(content_type)::CONTENT_TYPE
+
           sequence do
             concurrence do
               tmp_files.each do |file|
@@ -19,7 +23,7 @@ module Actions
                               file: file[:path])
                   plan_action(Pulp::Repository::ImportUpload,
                               pulp_id: repository.pulp_id,
-                              unit_type_id: repository.unit_type_id,
+                              unit_type_id: unit_type_id,
                               unit_key: unit_key(file, repository),
                               upload_id: upload_request.output[:upload_id])
                   plan_action(Pulp::Repository::DeleteUploadRequest,
@@ -27,7 +31,7 @@ module Actions
                 end
               end
             end
-            plan_action(FinishUpload, repository)
+            plan_action(FinishUpload, repository, content_type: content_type)
             plan_self(tmp_files: tmp_files)
           end
         ensure

data/app/lib/actions/katello/subscription/update.rb

@@ -0,0 +1,11 @@
+module Actions
+  module Katello
+    module Subscription
+      class Update < Actions::EntryAction
+        def plan(subscription, subscription_params)
+          subscription.update_attributes!(subscription_params)
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/upstream_subscriptions/remove_entitlement.rb

@@ -6,10 +6,13 @@ module Actions
 
         input_format do
           param :entitlement_id
+          param :sub_name
         end
 
         def run
           output[:response] = ::Katello::Resources::Candlepin::UpstreamConsumer.remove_entitlement(input[:entitlement_id])
+        rescue ::Katello::Errors::UpstreamEntitlementGone
+          output[:response] = _("%s has already been deleted" % input[:sub_name])
         end
 
         def run_progress_weight

data/app/lib/actions/katello/upstream_subscriptions/remove_entitlements.rb

@@ -3,6 +3,7 @@ module Actions
     module UpstreamSubscriptions
       class RemoveEntitlements < Actions::Base
         def plan(pool_ids = [])
+          ::Katello::Resources::Candlepin::UpstreamConsumer.get(:include_only => [:uuid])
           ids = pool_ids.uniq.compact
           fail _("No pool IDs were provided.") if ids.blank?
           fail _("Current organization is not set.") unless ::Organization.current
@@ -13,7 +14,9 @@ module Actions
 
               fail _("Provided pool with id %s has no upstream entitlement" % pid) if pool.upstream_entitlement_id.nil?
 
-              plan_action(::Actions::Katello::UpstreamSubscriptions::RemoveEntitlement, entitlement_id: pool.upstream_entitlement_id)
+              sub_name = pool.subscription.name
+
+              plan_action(::Actions::Katello::UpstreamSubscriptions::RemoveEntitlement, entitlement_id: pool.upstream_entitlement_id, sub_name: sub_name)
             end
 
             plan_action(::Actions::Katello::Organization::ManifestRefresh, ::Organization.current)

data/app/lib/actions/middleware/backend_services_check.rb

@@ -26,8 +26,16 @@ module Actions
       protected
 
       def capsule_id(args)
-        capsule_hash = args.select { |x| x[:capsule_id] if x.is_a? Hash }
-        capsule_hash[0] ? capsule_hash[0][:capsule_id] : nil
+        capsule_id = nil
+        args.each do |arg|
+          if arg.is_a? SmartProxy
+            capsule_id = arg.id
+          elsif arg.is_a? Hash
+            capsule_id = arg[:capsule_id] || arg[:smart_proxy_id]
+          end
+          break if capsule_id
+        end
+        capsule_id
       end
 
       def source_action

data/app/lib/actions/middleware/propagate_output.rb

@@ -0,0 +1,15 @@
+module Actions
+  module Middleware
+    class PropagateOutput < Dynflow::Middleware
+      def run(*args)
+        pass(*args)
+        if action.input.keys.include?('subaction_output') && action.input['subaction_output']
+          action.input['subaction_output'].each do |key, value|
+            self.action.output[key] = value
+          end
+          action.input.delete('subaction_output')
+        end
+      end
+    end
+  end
+end