katello 3.18.0.rc2.1 → 4.0.0.rc2

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

@@ -0,0 +1,34 @@
+module Katello
+  class Api::V2::SimpleContentAccessController < Api::V2::ApiController
+    before_action :find_organization
+    before_action :check_upstream_connection
+
+    resource_description do
+      description "Red Hat subscriptions management platform."
+      api_version 'v2'
+    end
+
+    api :GET, "/organizations/:organization_id/simple_content_access/eligible",
+      N_("Check if the specified organization is eligible for Simple Content Access")
+    def eligible
+      eligible = @organization.upstream_consumer.simple_content_access_eligible?
+      render json: { simple_content_access_eligible: eligible }
+    end
+
+    api :PUT, "/organizations/:organization_id/simple_content_access/enable",
+      N_("Enable simple content access for a manifest")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def enable
+      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
+      respond_for_async :resource => task
+    end
+
+    api :PUT, "/organizations/:organization_id/simple_content_access/disable",
+      N_("Disable simple content access for a manifest")
+    param :organization_id, :number, :desc => N_("Organization ID"), :required => true
+    def disable
+      task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
+      respond_for_async :resource => task
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ module Katello
                         :start_date, :end_date, :available, :quantity, :account_number, :contract_number,
                         :support_level, :ram, :stacking_id, :multi_entitlement, :type, :product_id,
                         :unmapped_guest, :virt_only, :virt_who, :upstream?],
-                       ['Pool Id', 'Subscription Id', 'Name', 'Candlepin Id', 'Organization Id',
+                       ['Pool Id Number', 'Subscription Id', 'Name', 'Pool Id', 'Organization Id',
                         'Sockets', 'Cores', 'Start Date', 'End Date', 'Available', 'Quantity', 'Account Number',
                         'Contract Number', 'Support Level', 'RAM', 'Stacking Id', 'Multi Entitlement', 'Type',
                         'Product Id', 'Unmapped Guest', 'Virt Only', 'Requires Virt Who', 'Upstream'])

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

@@ -2,7 +2,7 @@ module Katello
   class Api::V2::UpstreamSubscriptionsController < Api::V2::ApiController
     before_action :find_organization
     before_action :check_upstream_connection
-
+    before_action :deprecated, only: [:simple_content_access_eligible, :enable_simple_content_access, :disable_simple_content_access]
     resource_description do
       description "Red Hat subscriptions management platform."
       api_version 'v2'
@@ -78,14 +78,14 @@ module Katello
     end
 
     api :GET, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/eligible",
-      N_("Check if the specified organization is eligible for Simple Content Access")
+      N_("Check if the specified organization is eligible for Simple Content Access"), :deprecated => true
     def simple_content_access_eligible
       eligible = @organization.upstream_consumer.simple_content_access_eligible?
       render json: { simple_content_access_eligible: eligible }
     end
 
     api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/enable",
-      N_("Enable simple content access for a manifest")
+      N_("Enable simple content access for a manifest"), :deprecated => true
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def enable_simple_content_access
       task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Enable, params[:organization_id])
@@ -93,7 +93,7 @@ module Katello
     end
 
     api :PUT, "/organizations/:organization_id/upstream_subscriptions/simple_content_access/disable",
-      N_("Disable simple content access for a manifest")
+      N_("Disable simple content access for a manifest"), :deprecated => true
     param :organization_id, :number, :desc => N_("Organization ID"), :required => true
     def disable_simple_content_access
       task = async_task(::Actions::Katello::Organization::SimpleContentAccess::Disable, params[:organization_id])
@@ -124,5 +124,9 @@ module Katello
         { "pool" => pool[:id], "quantity" => pool[:quantity] } if pool
       end
     end
+
+    def deprecated
+      ::Foreman::Deprecation.api_deprecation_warning("This will be removed in Katello 4.2, Please see /api/v2/simple_content_access")
+    end
   end
 end

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

@@ -107,7 +107,7 @@ module Katello
       true
     end
 
-    def authorize_remove_environments(view, options)
+    def authorize_remove_environments(view, options) # rubocop:disable Metrics/CyclomaticComplexity
       env_ids = options[:environment_ids]
 
       return true if env_ids.blank?

data/app/helpers/katello/sync_management_helper.rb

@@ -35,8 +35,6 @@ module Katello
     module RepoMethods
       # returns all repos in hash representation with minors and arch children included
       def collect_repos(products, env, include_feedless = true)
-        Glue::Pulp::Repos.prepopulate! products, env, []
-
         products.map do |prod|
           minor_repos, repos_without_minor = collect_minor(prod.repos(env, nil, include_feedless))
           { :name => prod.name, :object => prod, :id => prod.id, :type => "product", :repos => repos_without_minor,

data/app/lib/actions/candlepin/environment/create.rb

@@ -13,7 +13,7 @@ module Actions
           ::Katello::Resources::Candlepin::Environment.create(input['organization_label'],
                                                    input['cp_id'],
                                                    input['name'],
-                                                   input['description'])
+                                                   input['description'].try(:truncate, 255))
         end
       end
     end

data/app/lib/actions/candlepin/environment/set_content.rb

@@ -9,7 +9,7 @@ module Actions
                     :new_content_id => new_content_id)
         end
 
-        def finalize
+        def finalize # rubocop:disable Metrics/AbcSize
           content_view = ::Katello::ContentView.find(input[:content_view_id])
           environment = ::Katello::KTEnvironment.find(input[:environment_id])
           content_ids = content_view.repos(environment).map(&:content_id).uniq.compact

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/agent/dispatch_history_presenter.rb

@@ -0,0 +1,64 @@
+module Actions
+  module Katello
+    module Agent
+      class DispatchHistoryPresenter
+        def initialize(dispatch_history, action_type)
+          @result = dispatch_history&.result&.with_indifferent_access
+          @action_type = action_type
+        end
+
+        def humanized_output
+          return if @result.empty?
+
+          result = package_result
+
+          if result[:message]
+            result[:message]
+          elsif result[:packages].any?
+            packages = result[:packages].map { |package| package[:qname] }
+            packages.sort.join("\n")
+          else
+            humanized_no_package
+          end
+        end
+
+        def error_messages
+          messages = []
+          @result.each_value do |result|
+            if !result[:succeeded] && result.dig(:details, :message)
+              messages << result[:details][:message]
+            end
+          end
+          messages
+        end
+
+        private
+
+        def package_result
+          result = { packages: [] }
+
+          @result.each_value do |v|
+            if v[:succeeded]
+              result[:packages].concat(v[:details][:resolved] + v[:details][:deps])
+              break
+            else
+              result[:message] = v[:details][:message]
+              break
+            end
+          end
+
+          result
+        end
+
+        def humanized_no_package
+          case @action_type
+          when :content_install
+            _("No new packages installed")
+          when :content_uninstall
+            _("No packages removed")
+          end
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/agent_action.rb

@@ -0,0 +1,107 @@
+module Actions
+  module Katello
+    class AgentAction < Actions::EntryAction
+      include Dynflow::Action::Timeouts
+      include Helpers::Presenter
+
+      def self.agent_message
+        fail NotImplementedError
+      end
+
+      def agent_action_type
+        nil
+      end
+
+      def plan(host, options)
+        action_subject(host, :hostname => host.name, :content => options[:content])
+
+        # if already dispatched by bulk action use the provided history ID
+        dispatch_history_id = options.dig(:dispatch_histories, host.id.to_s)
+
+        unless dispatch_history_id
+          histories = ::Katello::Agent::Dispatcher.dispatch(
+            self.class.agent_message,
+            [host.id],
+            content: options[:content]
+          )
+
+          dispatch_history_id = histories.first.id
+        end
+
+        plan_self(
+          host_id: host.id,
+          dispatch_history_id: dispatch_history_id
+        )
+      end
+
+      def run(event = nil)
+        case event
+        when nil
+          history = dispatch_history
+
+          if history.finished?
+            fail_on_errors
+            return
+          elsif history.accepted?
+            schedule_timeout(finish_timeout)
+          else
+            schedule_timeout(accept_timeout)
+          end
+
+          suspend do |suspended_action|
+            history.dynflow_execution_plan_id = suspended_action.execution_plan_id
+            history.dynflow_step_id = suspended_action.step_id
+            history.save!
+          end
+        when Dynflow::Action::Timeouts::Timeout
+          process_timeout
+        when 'accepted'
+          schedule_timeout(finish_timeout)
+          suspend
+        else
+          fail_on_errors
+        end
+      end
+
+      def accept_timeout
+        Setting['content_action_accept_timeout']
+      end
+
+      def finish_timeout
+        Setting['content_action_finish_timeout']
+      end
+
+      def process_timeout
+        history = dispatch_history
+
+        unless history.accepted?
+          fail _("Host did not respond within %s seconds. The task has been cancelled. Is katello-agent installed and goferd running on the Host?") % accept_timeout
+        end
+
+        unless history.finished?
+          fail _("Host did not finish content action in %s seconds.  The task has been cancelled.") % finish_timeout
+        end
+      end
+
+      def fail_on_errors
+        errors = presenter.error_messages
+
+        if errors.any?
+          fail errors.join("\n")
+        end
+      end
+
+      def presenter
+        Actions::Katello::Agent::DispatchHistoryPresenter.new(dispatch_history, agent_action_type)
+      end
+
+      def rescue_strategy
+        Dynflow::Action::Rescue::Skip
+      end
+
+      def dispatch_history
+        ::Katello::Agent::DispatchHistory.find_by_id(input[:dispatch_history_id])
+      end
+    end
+  end
+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/bulk_agent_action.rb

@@ -0,0 +1,21 @@
+module Actions
+  module Katello
+    class BulkAgentAction < Actions::BulkAction
+      def plan(agent_action, hosts, args)
+        host_ids = hosts.map(&:id)
+        dispatch_args = {
+          content: args[:content]
+        }
+        histories = ::Katello::Agent::Dispatcher.dispatch(agent_action.agent_message, host_ids, dispatch_args)
+
+        grouped_histories = {}
+        histories.each { |h| grouped_histories[h.host_id] = h.id }
+        options = {
+          dispatch_histories: grouped_histories,
+          content: args[:content]
+        }
+        super(agent_action, hosts, options)
+      end
+    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

@@ -19,9 +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)
@@ -30,6 +35,15 @@ module Actions
               end
             end
           end
+          update_unauthenticated_repo_list(smart_proxy) if smart_proxy.has_feature?("Container_Gateway")
+        end
+
+        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)

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