katello 3.4.0.rc2 → 3.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d3f9bb83c71845a3ecc9adb445e0204dd621f628
-  data.tar.gz: a6d9abc07ba6af4f223702bcb98eb8c920fe3397
+  metadata.gz: 7ca8f57b46bc9721e4c1fa328d529bbe1648c8c0
+  data.tar.gz: f307460b4ff1f4239a751a9bc9a85fe851372cb4
 SHA512:
-  metadata.gz: dc4d63a500dd8a93f8c2a9f0684cb4d10b30434e0bf4baa9da071282a2601687f0996d88064826e580692419977ce6d0918820449b530ee8c44848b28079f829
-  data.tar.gz: fcb2534fbe4cdcb8c5f1b691b23aed6c56d427c90a4e5aa917865329f3e4eac4cc3e4c0356576ea68fd2d60c164a8ead9bdf0fa4fb45b7b460321aa645ebf0f0
+  metadata.gz: 9e6dea22f805c400a91b25becc5ce63e3859fb041ae7332ee66fae6d96b9779aa85b97a6369e7ae8cbe70e14a2a5aa747be3cfaf87cb9ec739b2444f60c11d2b
+  data.tar.gz: e32a2ae850e272742cb546a77dc6a06ac01decfb9240d1d397a67e406dd56bc85b603df686f2ddae6d7bf1869e2a8d2b367a5384e719f053b67fa9c8b0b09c89

data/app/controllers/katello/api/rhsm/candlepin_dynflow_proxy_controller.rb

@@ -0,0 +1,43 @@
+module Katello
+  class Api::Rhsm::CandlepinDynflowProxyController < Api::V2::ApiController
+    include Katello::Authentication::ClientAuthentication
+    include ForemanTasks::Triggers
+    include AbstractController::Callbacks
+
+    skip_before_action :authorize, :only => [:upload_package_profile]
+    before_action :find_host, :only => [:upload_package_profile]
+    before_action :authorize_client_or_user, :only => [:upload_package_profile]
+
+    #api :PUT, "/consumers/:id/packages", N_("Update installed packages")
+    #api :PUT, "/consumers/:id/profile", N_("Update installed packages")
+    #param :id, String, :desc => N_("UUID of the consumer"), :required => true
+    def upload_package_profile
+      User.as_anonymous_admin do
+        async_task(::Actions::Katello::Host::UploadPackageProfile, @host, request.raw_post)
+      end
+      render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
+    end
+
+    def find_host(uuid = nil)
+      params = request.path_parameters
+      uuid ||= params[:id]
+      facet = Katello::Host::SubscriptionFacet.where(:uuid => uuid).first
+      if facet.nil?
+        # check with candlepin if consumer is Gone, raises RestClient::Gone
+        User.as_anonymous_admin { Resources::Candlepin::Consumer.get(uuid) }
+        fail HttpErrors::NotFound, _("Couldn't find consumer '%s'") % uuid
+      end
+      @host = facet.host
+    end
+
+    def authorize_client_or_user
+      client_authorized? || authorize
+    end
+
+    def client_authorized?
+      authorized = authenticate_client && User.consumer?
+      authorized = (User.current.uuid == @host.subscription_facet.uuid) if @host && User.consumer?
+      authorized
+    end
+  end
+end

data/app/controllers/katello/api/rhsm/candlepin_proxies_controller.rb

@@ -11,8 +11,8 @@ module Katello
                                         :upload_package_profile, :regenerate_identity_certificates, :facts,
                                         :available_releases, :serials, :upload_tracer_profile]
     before_action :authorize, :only => [:consumer_create, :list_owners, :rhsm_index]
-    before_action :authorize_client_or_user, :only => [:consumer_show, :upload_package_profile, :regenerate_identity_certificates, :upload_tracer_profile, :facts]
-    before_action :authorize_client_or_admin, :only => [:hypervisors_update]
+    before_action :authorize_client_or_user, :only => [:consumer_show, :upload_package_profile, :regenerate_identity_certificates, :upload_tracer_profile, :facts, :proxy_jobs_get_path]
+    before_action :authorize_client_or_admin, :only => [:hypervisors_update, :async_hypervisors_update]
     before_action :authorize_proxy_routes, :only => [:get, :post, :put, :delete]
     before_action :authorize_client, :only => [:consumer_destroy, :consumer_checkin,
                                                :enabled_repos, :available_releases]
@@ -20,8 +20,10 @@ module Katello
     before_action :add_candlepin_version_header
 
     before_action :proxy_request_path, :proxy_request_body
-    before_action :set_organization_id, :except => :hypervisors_update
-    before_action :find_hypervisor_organization, :only => [:hypervisors_update]
+    before_action :set_organization_id, :except => [:hypervisors_update, :async_hypervisors_update]
+    before_action :find_hypervisor_organization, :only => [:async_hypervisors_update, :hypervisors_update]
+
+    before_action :check_content_type, :except => :async_hypervisors_update
 
     def repackage_message
       yield
@@ -108,6 +110,17 @@ module Katello
       respond_for_index :collection => @all_environments
     end
 
+    #api :POST, "/hypervisors/OWNER"
+    # Note that this request comes in as content-type 'text/plain' so that
+    # tomcat won't parse the json.  Here we just pass the plain body through to candlepin
+    def async_hypervisors_update
+      raw_json = request.body.string
+      task = Katello::Resources::Candlepin::Consumer.async_hypervisors(params[:owner], raw_json)
+      async_task(::Actions::Katello::Host::Hypervisors, nil, :task_id => task['id'])
+
+      render :json => task
+    end
+
     #api :POST, "/hypervisors", N_("Update the hypervisors information for environment")
     #desc 'See virt-who tool for more details.'
     def hypervisors_update
@@ -128,16 +141,6 @@ module Katello
       render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
     end
 
-    #api :PUT, "/consumers/:id/packages", N_("Update installed packages")
-    #api :PUT, "/consumers/:id/profile", N_("Update installed packages")
-    #param :id, String, :desc => N_("UUID of the consumer"), :required => true
-    def upload_package_profile
-      User.as_anonymous_admin do
-        async_task(::Actions::Katello::Host::UploadPackageProfile, @host, params[:_json])
-      end
-      render :json => Resources::Candlepin::Consumer.get(@host.subscription_facet.uuid)
-    end
-
     api :PUT, "/consumers/:id/tracer", N_("Update services requiring restart")
     param :traces, Hash, :required => true
     def upload_tracer_profile
@@ -443,6 +446,7 @@ module Katello
     end
 
     # rubocop:disable MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity
     def authorize_proxy_routes
       deny_access unless (authenticate || authenticate_client)
 
@@ -486,6 +490,8 @@ module Katello
         User.consumer?
       when "rhsm_proxy_deleted_consumers_path"
         current_user.admin?
+      when "rhsm_proxy_jobs_get_path"
+        User.consumer? || current_user.admin?
       else
         Rails.logger.warn "Unknown proxy route #{request.method} #{request.fullpath}, access denied"
         deny_access

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

@@ -41,8 +41,8 @@ module Katello
       content_views = content_views.where(:organization_id => @organization.id) if @organization
       content_views = content_views.in_environment(@environment) if @environment
       content_views = content_views.non_default if params[:nondefault]
-      content_views = content_views.non_composite if params[:noncomposite]
-      content_views = content_views.composite if params[:composite]
+      content_views = ::Foreman::Cast.to_bool(params[:noncomposite]) ? content_views.non_composite : content_views.composite if params[:noncomposite]
+      content_views = ::Foreman::Cast.to_bool(params[:composite]) ? content_views.composite : content_views.non_composite if params[:composite]
       content_views = content_views.where(:name => params[:name]) if params[:name]
       content_views = content_views.where("#{ContentView.table_name}.id NOT IN (?)", params[:without]) if params[:without]
       content_views

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

@@ -37,6 +37,7 @@ module Katello
     def custom_index_relation(collection)
       collection = filter_by_cve(params[:cve], collection) if params[:cve]
       hosts = ::Host::Managed.authorized("view_hosts")
+      hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
       if ::Foreman::Cast.to_bool(params[:errata_restrict_applicable])
         collection = collection.applicable_to_hosts(hosts)
       end

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

@@ -45,13 +45,17 @@ module Katello
         if @host
           collection = collection.installable_for_hosts([@host])
         else
-          collection = collection.installable_for_hosts(::Host::Managed.authorized("view_hosts"))
+          hosts = ::Host::Managed.authorized("view_hosts")
+          hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
+          collection = collection.installable_for_hosts(hosts)
         end
       elsif ::Foreman::Cast.to_bool(params[:packages_restrict_applicable]) || @host
         if @host
           collection = collection.applicable_to_hosts([@host])
         else
-          collection = collection.applicable_to_hosts(::Host::Managed.authorized("view_hosts"))
+          hosts = ::Host::Managed.authorized("view_hosts")
+          hosts = hosts.where(:organization_id => params[:organization_id]) if params[:organization_id]
+          collection = collection.applicable_to_hosts(hosts)
         end
       end
 

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

@@ -0,0 +1,22 @@
+module Actions
+  module Candlepin
+    class AsyncHypervisors < Candlepin::AbstractAsyncTask
+      # this action is for tracking an async candlepin task when the task id is already known
+      input_format do
+        param :task_id
+      end
+
+      def poll_external_task(task_id = external_task[:id])
+        task = ::Katello::Resources::Candlepin::Job.get(task_id, :result_data => true)
+        unless ::Katello::Resources::Candlepin::Job.not_finished?(task)
+          output[:hypervisors] = ::Actions::Katello::Host::Hypervisors.parse_hypervisors(task.delete('resultData'))
+        end
+        task
+      end
+
+      def invoke_external_task
+        poll_external_task(input[:task_id])
+      end
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module Actions
         when /entitlement\.created/
           import_pool(wrapped_message.content['referenceId'])
         when /entitlement\.deleted/
-          import_or_remove_pool(wrapped_message.content['referenceId'])
+          import_pool(wrapped_message.content['referenceId'])
         when /pool\.created/
           import_pool(wrapped_message.content['entityId'])
         when /pool\.deleted/
@@ -44,17 +44,13 @@ module Actions
 
       private
 
-      def import_or_remove_pool(pool_id)
-        pool = ::Katello::Pool.find_by(:cp_id => pool_id)
-        pool.nil? ? remove_pool(pool_id) : pool.import_data
-      rescue RestClient::ResourceNotFound
-        remove_pool(pool_id)
-      end
-
       def import_pool(pool_id)
-        ::Katello::Pool.import_pool(pool_id)
-      rescue RestClient::ResourceNotFound
-        @logger.debug "skipped re-index of non-existent pool #{pool_id}"
+        pool = ::Katello::Pool.find_by(:cp_id => pool_id)
+        if pool
+          ::Katello::EventQueue.push_event(::Katello::Events::ImportPool::EVENT_TYPE, pool.id)
+        else
+          ::Katello::Pool.import_pool(pool_id)
+        end
       end
 
       def remove_pool(pool_id)
@@ -68,18 +64,18 @@ module Actions
 
       def reindex_consumer(message)
         if message.content['newEntity']
-          uuid = JSON.parse(message.content['newEntity'])['consumer']['uuid']
-          skip_msg = "skip re-indexing of non-existent content host #{uuid}"
-          begin
-            subscription_facet = ::Katello::Host::SubscriptionFacet.find_by_uuid(uuid)
-            if subscription_facet.nil?
-              @logger.debug "skip re-indexing of non-existent registered host #{uuid}"
-            else
-              @logger.debug "re-indexing content host #{subscription_facet.host.name}"
-              subscription_facet.update_subscription_status
-            end
-          rescue RestClient::ResourceNotFound, RestClient::Gone
-            @logger.debug(skip_msg)
+          parsed = JSON.parse(message.content['newEntity'])
+          uuid = parsed['consumer']['uuid']
+          sub_status = parsed['consumer']['entitlementStatus']
+          subscription_facet = ::Katello::Host::SubscriptionFacet.find_by_uuid(uuid)
+
+          if subscription_facet && sub_status
+            @logger.debug "re-indexing content host #{subscription_facet.host.name}"
+            subscription_facet.update_subscription_status(sub_status)
+          elsif subscription_facet.nil?
+            @logger.debug "skip re-indexing of non-existent content host #{uuid}"
+          elsif sub_status.nil?
+            @logger.debug "skip re-indexing of empty subscription status #{uuid}"
           end
         end
       end

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

@@ -12,6 +12,7 @@ module Actions
 
         def plan(capsule_content, options = {})
           capsule_content.ping_pulp
+          capsule_content.verify_ueber_certs
           action_subject(capsule_content.capsule)
 
           environment = options.fetch(:environment, nil)

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

@@ -2,14 +2,22 @@ module Actions
   module Katello
     module Host
       class Hypervisors < Actions::EntryAction
-        def plan(hypervisor_params)
+        def plan(hypervisor_params, options = {})
+          task_id = options.fetch(:task_id, nil)
           sequence do
-            hypervisor_results = ::Katello::Resources::Candlepin::Consumer.register_hypervisors(hypervisor_params)
-            plan_action(Katello::Host::HypervisorsUpdate, parse_hypervisors(hypervisor_results))
+            if task_id
+              task_output = plan_action(Candlepin::AsyncHypervisors, :task_id => task_id).output
+              parsed_response = task_output[:hypervisors]
+            elsif hypervisor_params
+              hypervisor_results = ::Katello::Resources::Candlepin::Consumer.register_hypervisors(hypervisor_params)
+              parsed_response = Hypervisors.parse_hypervisors(hypervisor_results)
+            end
+            plan_self(:hypervisors => parsed_response)
+            plan_action(Katello::Host::HypervisorsUpdate, :hypervisors => parsed_response)
           end
         end
 
-        def parse_hypervisors(hypervisor_results)
+        def self.parse_hypervisors(hypervisor_results)
           hypervisors = []
           %w(created updated unchanged).each do |group|
             if hypervisor_results[group]
@@ -24,6 +32,10 @@ module Actions
           end
           hypervisors
         end
+
+        def rescue_strategy
+          Dynflow::Action::Rescue::Skip
+        end
       end
     end
   end

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

@@ -4,8 +4,8 @@ module Actions
       class HypervisorsUpdate < Actions::EntryAction
         middleware.use ::Actions::Middleware::RemoteAction
 
-        def plan(hypervisors)
-          plan_self(:hypervisors => hypervisors)
+        input_format do
+          param :hypervisors
         end
 
         def run

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

@@ -4,14 +4,10 @@ module Actions
       class UploadPackageProfile < Actions::EntryAction
         middleware.use Actions::Middleware::KeepCurrentUser
 
-        def plan(host, profile)
+        def plan(host, profile_string)
           action_subject host
 
-          ::Katello::Pulp::Consumer.new(host.content_facet.uuid).upload_package_profile(profile) if host.content_facet.uuid
-          simple_packages = profile.map { |item| ::Katello::Pulp::SimplePackage.new(item) }
-          host.import_package_profile(simple_packages)
-
-          plan_self(:hostname => host.name)
+          plan_self(:host_id => host.id, :hostname => host.name, :profile_string => profile_string)
           plan_action(GenerateApplicability, [host])
         end
 
@@ -30,6 +26,17 @@ module Actions
         def rescue_strategy
           Dynflow::Action::Rescue::Skip
         end
+
+        def run
+          host = ::Host.find(input[:host_id])
+          profile = JSON.parse(input[:profile_string])
+          #free the huge string from the memory
+          input[:profile_string] = 'TRIMMED'.freeze
+
+          ::Katello::Pulp::Consumer.new(host.content_facet.uuid).upload_package_profile(profile) if host.content_facet.uuid
+          simple_packages = profile.map { |item| ::Katello::Pulp::SimplePackage.new(item) }
+          host.import_package_profile(simple_packages)
+        end
       end
     end
   end

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

@@ -2,6 +2,8 @@ module Actions
   module Katello
     module Repository
       class RemoveContent < Actions::EntryAction
+        include Dynflow::Action::WithSubPlans
+
         middleware.use Actions::Middleware::KeepCurrentUser
 
         def plan(repository, content_units, options = {})
@@ -33,13 +35,16 @@ module Actions
             plan_action(pulp_action, :pulp_id => repository.pulp_id,
                                      :clauses => {:association => {'unit_id' => {'$in' => uuids}}
             })
-
-            plan_self(:repository_id => repository.id, :user_id => ::User.current.id,
-                      sync_capsule: sync_capsule)
+            plan_self
             plan_action(CapsuleGenerateAndSync, repository) if sync_capsule
           end
         end
 
+        def create_sub_plans
+          trigger(Actions::Katello::Repository::MetadataGenerate,
+                  ::Katello::Repository.find(input[:repository_id]))
+        end
+
         def resource_locks
           :link
         end
@@ -47,11 +52,6 @@ module Actions
         def humanized_name
           _("Remove Content")
         end
-
-        def run
-          output[:task_id] = ForemanTasks.sync_task(Actions::Katello::Repository::MetadataGenerate,
-                                                    ::Katello::Repository.find(input[:repository_id])).id
-        end
       end
     end
   end

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

@@ -32,8 +32,8 @@ module Actions
 
       def source_action
         parent = self.action
-        until parent.trigger.nil?
-          parent = parent.trigger
+        until parent.triggering_action.nil?
+          parent = parent.triggering_action
         end
         parent
       end

data/app/lib/katello/capsule_content.rb

@@ -147,6 +147,12 @@ module Katello
       raise ::Katello::Errors::CapsuleCannotBeReached, _("%s is unreachable. %s" % [@capsule.name, error])
     end
 
+    def verify_ueber_certs
+      self.capsule.organizations.each do |org|
+        Cert::Certs.verify_ueber_cert(org)
+      end
+    end
+
     def self.with_environment(environment, include_default = false)
       features = [SmartProxy::PULP_NODE_FEATURE]
       features << SmartProxy::PULP_FEATURE if include_default

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

@@ -117,6 +117,14 @@ module Katello
             JSON.parse(response).with_indifferent_access
           end
 
+          def async_hypervisors(owner, raw_json)
+            url = "/candlepin/hypervisors/#{owner}"
+            headers = self.default_headers
+            headers['content-type'] = 'text/plain'
+            response = self.post(url, raw_json, headers)
+            JSON.parse(response).with_indifferent_access
+          end
+
           def register_hypervisors(params)
             url = "/candlepin/hypervisors"
             url << "?owner=#{params[:owner]}&env=#{params[:env]}"
@@ -369,11 +377,8 @@ module Katello
 
           def import(organization_name, path_to_file, options)
             path = join_path(path(organization_name), 'imports')
-
-            query_params = {}
-            query_params[:force] = true if options[:force] == "true"
-            unless query_params.empty?
-              path << "?" << query_params.to_param
+            if options[:force] || SETTINGS[:katello].key?(:force_manifest_import)
+              path += "?force=#{SETTINGS[:katello][:force_manifest_import]}"
             end
 
             self.post(path, {:import => File.new(path_to_file, 'rb')}, self.default_headers.except('content-type'))
@@ -620,8 +625,8 @@ module Katello
             NOT_FINISHED_STATES.include?(job[:state])
           end
 
-          def get(id)
-            job_json = super(path(id), self.default_headers).body
+          def get(id, params = {})
+            job_json = super(path(id) + hash_to_query(params), self.default_headers).body
             job = JSON.parse(job_json)
             job.with_indifferent_access
           end