katello 3.4.2 → 3.4.4

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

@@ -38,7 +38,7 @@ module Katello
           fail "Unsupported default_sort type"
         end
 
-        respond(:collection => scoped_search(index_relation.uniq, sort_options[0], sort_options[1], options))
+        respond(:collection => scoped_search(index_relation, sort_options[0], sort_options[1], options))
       end
 
       api :GET, "/:resource_id/:id", N_("Show :a_resource")
@@ -74,17 +74,19 @@ module Katello
       param :filterId, :integer, :desc => N_("Content View Filter id")
       def index_relation
         collection = resource_class.all
-        collection = filter_by_repos(Repository.readable, collection)
-        collection = filter_by_repos([@repo], collection) if @repo
-        collection = filter_by_content_view_version(@version, collection) if @version
+        repos = Repository.readable
+        repos = repos.where(:id => @repo) if @repo
+        repos = repos.where(:id => Repository.readable.in_organization(@organization)) if @organization
         if @environment && (@environment.library? || resource_class != Katello::PuppetModule)
           # if the environment is not library and this is for puppet modules,
           # we can skip environment filter, as those would be associated to
           # content view puppet environments and handled by the puppet modules
           # controller.
-          collection = filter_by_environment(@environment, collection)
+          repos = repos.where(:id => @environment.repositories)
         end
-        collection = filter_by_repos(Repository.readable.in_organization(@organization), collection) if @organization
+
+        collection = filter_by_repos(repos, collection)
+        collection = filter_by_content_view_version(@version, collection) if @version
         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)
@@ -115,10 +117,6 @@ module Katello
         collection.where(:id => version.send(controller_name))
       end
 
-      def filter_by_environment(environment, collection)
-        filter_by_repos(environment.repositories, collection)
-      end
-
       def find_content_resource
         @resource = resource_class.with_identifiers(params[:id]).first
 

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -198,9 +198,9 @@ module Katello
         new_host.architecture = param_host.architecture.present? ? param_host.architecture : host.architecture
 
         if (host.is_a? Hostgroup)
-          new_host.content_facet = ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => host.lifecycle_environment_id,
-                                                          :content_view_id => host.content_view_id,
-                                                          :content_source_id => host.content_source_id)
+          new_host.content_facet = ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => host.inherited_lifecycle_environment_id,
+                                                          :content_view_id => host.inherited_content_view_id,
+                                                          :content_source_id => host.inherited_content_source_id)
         elsif host.content_facet.present?
           new_host.content_facet = ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => host.content_facet.lifecycle_environment_id,
                                                           :content_view_id => host.content_facet.content_view_id,

data/app/helpers/katello/layout_helper.rb

@@ -1,5 +1,7 @@
 module Katello
   module LayoutHelper
+    include ::LayoutHelper
+
     def stylesheet(*args)
       args.map { |arg| content_for(:stylesheets) { stylesheet_link_tag(arg) } }
       return ""

data/app/lib/actions/candlepin/consumer/update.rb

@@ -9,6 +9,7 @@ module Actions
 
         def run
           ::Katello::Resources::Candlepin::Consumer.update(input[:uuid], input[:consumer_params])
+          output[:uuid] = input[:uuid]
         end
 
         def finalize

data/app/lib/actions/candlepin/import_pool_handler.rb

@@ -66,7 +66,7 @@ module Actions
         if message.content['newEntity']
           parsed = JSON.parse(message.content['newEntity'])
           uuid = parsed['consumer']['uuid']
-          sub_status = parsed['consumer']['entitlementStatus']
+          sub_status = parsed['status']['status']
           subscription_facet = ::Katello::Host::SubscriptionFacet.find_by_uuid(uuid)
 
           if subscription_facet && sub_status

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

@@ -8,7 +8,7 @@ module Actions
 
           need_removal = currently_on_capsule - needed_on_capsule
           need_removal += capsule_content.orphaned_repos
-          need_removal.each do |pulp_id|
+          need_removal.compact.each do |pulp_id|
             plan_action(Pulp::Repository::Destroy,
                         :pulp_id => pulp_id,
                         :capsule_id => capsule_content.capsule.id)

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

@@ -6,18 +6,30 @@ module Actions
           :link
         end
 
+        input_format do
+          param :name
+        end
+
         def humanized_name
-          _("Synchronize capsule content")
+          _("Synchronize smart proxy")
         end
 
-        def plan(capsule_content, options = {})
+        def humanized_input
+          ["'#{input['smart_proxy']['name']}'"] + super
+        end
+
+        def plan(smart_proxy, options = {})
+          action_subject(smart_proxy)
+          capsule_content = ::Katello::CapsuleContent.new(smart_proxy)
           capsule_content.ping_pulp
           capsule_content.verify_ueber_certs
-          action_subject(capsule_content.capsule)
 
-          environment = options.fetch(:environment, nil)
-          repository = options.fetch(:repository, nil)
-          content_view = options.fetch(:content_view, nil)
+          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
 
           fail _("Action not allowed for the default capsule.") if capsule_content.default_capsule?
 
@@ -31,7 +43,6 @@ module Actions
               end
               plan_action(ConfigureCapsule, capsule_content, environment, content_view, repository)
               sync_repos_to_capsule(capsule_content, repository_ids)
-              plan_action(RemoveOrphans, :capsule_id => capsule_content.capsule.id)
             end
           end
         end
@@ -40,19 +51,18 @@ module Actions
           concurrence do
             repository_ids.each do |repo_id|
               sequence do
-                repo = ::Katello::Repository.where(:pulp_id => repo_id).first ||
-                       ::Katello::ContentViewPuppetEnvironment.where(:pulp_id => repo_id).first
-                if repo && repo.content_type != "yum"
-                  # we unassociate units in non-yum repos in order to avoid version conflicts
-                  # during publish. (i.e. two versions of a puppet module in the same repo)
+                repo = ::Katello::Repository.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: capsule_content.capsule.id,
                               repo_pulp_id: repo_id)
                 end
-
                 plan_action(Pulp::Consumer::SyncCapsule,
                             capsule_id: capsule_content.capsule.id,
-                            repo_pulp_id: repo_id)
+                            repo_pulp_id: repo_id,
+                            sync_options: { remove_missing: repo && ["puppet", "yum"].include?(repo.content_type) })
               end
             end
           end

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

@@ -3,15 +3,16 @@ module Actions
     module ContentView
       class CapsuleGenerateAndSync < Actions::Base
         def humanized_name
-          _("Sync Smart proxy with Content View")
+          _("Sync Content View on Smart Proxy(ies)")
         end
 
         def plan(content_view, environment)
           sequence do
             concurrence do
-              ::Katello::CapsuleContent.with_environment(environment).each do |capsule_content|
-                plan_action(Katello::CapsuleContent::Sync, capsule_content, :content_view => content_view,
-                            :environment => environment)
+              smart_proxies = ::Katello::CapsuleContent.with_environment(environment).map { |capsule| capsule.capsule }
+              unless smart_proxies.blank?
+                plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies,
+                            :content_view_id => content_view.id, :environment_id => environment.id)
               end
             end
           end

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

@@ -11,7 +11,7 @@ module Actions
 
           content_view = ::Katello::ContentView.find(input[:content_view])
           environment = ::Katello::KTEnvironment.find(input[:environment])
-          users = ::User.select { |user| user.receives?(:promote_errata) && user.can?(:view_content_views, content_view) }
+          users = ::User.select { |user| user.receives?(:promote_errata) && user.organization_ids.include?(content_view.organization_id) && user.can?(:view_content_views, content_view) }
 
           begin
             MailNotification[:promote_errata].deliver_now(:users => users, :content_view => content_view, :environment => environment) unless users.blank?

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

@@ -5,7 +5,9 @@ module Actions
         def plan(puppet_environment, clone = false)
           internal_capsule = SmartProxy.default_capsule
           fail _("Content View %s  cannot be published without an internal capsule." % puppet_environment.name) unless internal_capsule
-          puppet_environment.save!
+
+          User.as_anonymous_admin { puppet_environment.save! }
+
           action_subject(puppet_environment)
           plan_self
 

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

@@ -6,8 +6,6 @@ module Actions
 
         def plan(host, consumer_params = nil)
           action_subject host
-          plan_self(:hostname => host.name, :facts => consumer_params.try(:[], :facts), :host_id => host.id)
-
           sequence do
             host.content_facet.save! if host.content_facet
 
@@ -15,24 +13,34 @@ module Actions
               unless consumer_params
                 consumer_params = host.subscription_facet.consumer_attributes
               end
-
-              host.subscription_facet.update_from_consumer_attributes(consumer_params)
-              host.subscription_facet.save!
-              plan_action(::Actions::Candlepin::Consumer::Update, host.subscription_facet.uuid, consumer_params)
+              cp_update = plan_action(::Actions::Candlepin::Consumer::Update, host.subscription_facet.uuid, consumer_params)
             end
 
-            if host.subscription_facet.try(:autoheal)
+            if consumer_params.present? && consumer_params['autoheal']
               plan_action(::Actions::Candlepin::Consumer::AutoAttachSubscriptions, :uuid => host.subscription_facet.uuid)
             end
+
+            plan_self(:hostname => host.name, :consumer_params => consumer_params, :host_id => host.id,
+                      :dependency => cp_update.try(:output))
           end
         end
 
         def run
           User.as_anonymous_admin do
             host = ::Host.find(input[:host_id])
-            unless input[:facts].blank?
-              ::Katello::Host::SubscriptionFacet.update_facts(host, input[:facts])
-              input[:facts] = 'TRIMMED'
+            unless input[:consumer_params][:facts].blank?
+              ::Katello::Host::SubscriptionFacet.update_facts(host, input[:consumer_params][:facts])
+            end
+          end
+        end
+
+        def finalize
+          User.as_anonymous_admin do
+            unless input[:consumer_params].blank?
+              host = ::Host.find(input[:host_id])
+              host.subscription_facet.update_from_consumer_attributes(input[:consumer_params])
+              host.subscription_facet.save!
+              input[:consumer_params][:facts] = 'TRIMMED' unless input[:consumer_params][:facts].blank?
             end
           end
         end

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

@@ -7,8 +7,10 @@ module Actions
         def plan(host, profile_string)
           action_subject host
 
-          plan_self(:host_id => host.id, :hostname => host.name, :profile_string => profile_string)
-          plan_action(GenerateApplicability, [host])
+          sequence do
+            plan_self(:host_id => host.id, :hostname => host.name, :profile_string => profile_string)
+            plan_action(GenerateApplicability, [host])
+          end
         end
 
         def humanized_name

data/app/lib/actions/katello/organization/manifest_refresh.rb

@@ -12,29 +12,36 @@ module Actions
           upstream = details['upstreamConsumer'].blank? ? {} : details['upstreamConsumer']
 
           sequence do
-            plan_action(Candlepin::Owner::UpstreamRegenerateCertificates,
+            regen_certs = plan_action(Candlepin::Owner::UpstreamRegenerateCertificates,
                         :organization_id => organization.id,
                         :upstream => upstream)
-            plan_action(Candlepin::Owner::UpstreamUpdate,
+            upstream_update = plan_action(Candlepin::Owner::UpstreamUpdate,
                         :organization_id => organization.id,
-                        :upstream => upstream)
-            plan_action(Candlepin::Owner::UpstreamExport,
+                        :upstream => upstream,
+                        :dependency => regen_certs.output)
+            export_action = plan_action(Candlepin::Owner::UpstreamExport,
                         :organization_id => organization.id,
                         :upstream => upstream,
-                        :path => path)
-            plan_action(Candlepin::Owner::Import,
+                        :path => path,
+                        :dependency => upstream_update.output)
+            owner_import = plan_action(Candlepin::Owner::Import,
                         :label => organization.label,
-                        :path => path)
-            plan_action(Candlepin::Owner::ImportProducts, :organization_id => organization.id)
+                        :path => path,
+                        :dependency => export_action.output)
+            import_products = plan_action(Candlepin::Owner::ImportProducts, :organization_id => organization.id, :dependency => owner_import.output)
 
             if manifest_update && SETTINGS[:katello][:use_pulp]
               organization.products.redhat.flat_map(&:repositories).each do |repo|
-                plan_action(Katello::Repository::RefreshRepository, repo)
+                plan_action(Katello::Repository::RefreshRepository, repo, :dependency => import_products.output)
               end
             end
           end
         end
 
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
+
         def humanized_name
           _("Refresh Manifest")
         end

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

@@ -3,14 +3,16 @@ module Actions
     module Repository
       class CapsuleGenerateAndSync < Actions::Base
         def humanized_name
-          _("Sync Repository on Smart proxy(ies)")
+          _("Sync Repository on Smart Proxy(ies)")
         end
 
         def plan(repo)
           if repo.node_syncable?
             concurrence do
-              ::Katello::CapsuleContent.with_environment(repo.environment).each do |capsule_content|
-                plan_action(Katello::CapsuleContent::Sync, capsule_content, repository: repo)
+              smart_proxies = ::Katello::CapsuleContent.with_environment(repo.environment).map { |c| c.capsule }
+              unless smart_proxies.blank?
+                plan_action(::Actions::BulkAction, ::Actions::Katello::CapsuleContent::Sync, smart_proxies,
+                            :repository_id => repo.id)
               end
             end
           end

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

@@ -13,7 +13,7 @@ module Actions
           ::User.current = ::User.anonymous_admin
 
           repo = ::Katello::Repository.find(input[:repo])
-          users = ::User.select { |user| user.receives?(:sync_errata) && user.can?(:view_products, repo.product) }.compact
+          users = ::User.select { |user| user.receives?(:sync_errata) && user.organization_ids.include?(repo.organization.id) && user.can?(:view_products, repo.product) }.compact
           errata = ::Katello::Erratum.where(:id => repo.repository_errata.where('katello_repository_errata.updated_at > ?', input[:last_updated].to_datetime).pluck(:erratum_id))
 
           begin

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

@@ -2,11 +2,11 @@ module Actions
   module Katello
     module Repository
       class RefreshRepository < Actions::Base
-        def plan(repo)
+        def plan(repo, options = {})
           User.as_anonymous_admin do
             repo = ::Katello::Repository.find(repo.id)
-            plan_action(Pulp::Repository::Refresh, repo, :capsule_id => SmartProxy.default_capsule!.id)
-            plan_self(:name => repo.name)
+            plan_action(Pulp::Repository::Refresh, repo, :capsule_id => SmartProxy.default_capsule!.id, :dependency => options[:dependency])
+            plan_self(:name => repo.name, :dependency => options[:dependency])
           end
         end
       end

data/app/lib/actions/pulp/abstract_async_task_group.rb

@@ -2,6 +2,7 @@ module Actions
   module Pulp
     class AbstractAsyncTaskGroup < Pulp::Abstract
       include Actions::Base::Polling
+      include ::Dynflow::Action::Cancellable
 
       # A call report (documented https://github.com/pulp/pulp/blob/master/docs/dev-guide/integration/rest-api/consumer/applicability.rst#id65)
       # Looks like:
@@ -31,6 +32,23 @@ module Actions
         end
       end
 
+      def cancel!
+        cancel
+        self.external_task = poll_external_task
+        # We suspend the action and the polling will take care of finding
+        # out if the cancelling was successful
+        suspend unless done?
+      end
+
+      def cancel
+        group = output['pulp_task_group']
+        if group
+          task_resource.cancel(group['id'])
+        end
+      rescue RestClient::ResourceNotFound
+        nil #Pulp throws a 404 if there are no tasks in the task group https://pulp.plan.io/issues/2943
+      end
+
       def humanized_state
         case state
         when :running

data/app/lib/actions/pulp/consumer/sync_capsule.rb

@@ -5,6 +5,7 @@ module Actions
         input_format do
           param :capsule_id, Integer
           param :repo_pulp_id, String
+          param :sync_options
         end
 
         def humanized_name
@@ -12,7 +13,7 @@ module Actions
         end
 
         def invoke_external_task
-          pulp_resources.repository.sync(input[:repo_pulp_id])
+          pulp_resources.repository.sync(input[:repo_pulp_id], override_config: input[:sync_options])
         end
 
         def run_progress

data/app/lib/katello/resources/candlepin.rb

@@ -295,9 +295,9 @@ module Katello
 
             uri.scheme = URI.parse(proxy_config[:host]).scheme
             uri.host = URI.parse(proxy_config[:host]).host
-            uri.port = proxy_config[:port].to_s
-            uri.user = proxy_config[:user].to_s
-            uri.password = proxy_config[:password].to_s
+            uri.port = proxy_config[:port].try(:to_s)
+            uri.user = proxy_config[:user].try(:to_s)
+            uri.password = proxy_config[:password].try(:to_s)
 
             RestClient.proxy = uri.to_s
           end
@@ -306,7 +306,9 @@ module Katello
                                    :ssl_client_cert => OpenSSL::X509::Certificate.new(client_cert),
                                    :ssl_client_key => OpenSSL::PKey::RSA.new(client_key),
                                    :ssl_ca_file => ca_file,
-                                   :verify_ssl => ca_file ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+                                   :verify_ssl => ca_file ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE,
+                                   :open_timeout => Setting[:manifest_refresh_timeout],
+                                   :timeout => Setting[:manifest_refresh_timeout]
                                   )
         end
 
@@ -673,9 +675,10 @@ module Katello
             subscriptions = JSON.parse(subscriptions_json)
 
             product_subscription = subscriptions.find do |sub|
-              sub["product"]["id"] == id ||
+              sub['certificate'] &&
+              (sub["product"]["id"] == id ||
                 sub["providedProducts"].any? { |provided| provided["id"] == id } ||
-                sub["derivedProvidedProducts"].any? { |provided| provided["id"] == id }
+                sub["derivedProvidedProducts"].any? { |provided| provided["id"] == id })
             end
 
             if product_subscription