katello 4.4.1 → 4.5.0

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

@@ -13,7 +13,7 @@ module Katello
     before_action :find_authorized_host, :only => [:index, :auto_complete_search]
     before_action :find_organization
     before_action :find_product_content, :except => [:index, :auto_complete_search]
-    before_action :check_airgapped, :only => [:index]
+    before_action :check_airgapped, :only => [:available_repositories, :enable, :disable]
 
     resource_description do
       api_version "v2"
@@ -31,13 +31,19 @@ module Katello
     param :host_id, :number, :desc => N_("Id of the host"), :required => false
     param :content_access_mode_all, :bool, :desc => N_("Get all content available, not just that provided by subscriptions.")
     param :content_access_mode_env, :bool, :desc => N_("Limit content to just that available in the host's or activation key's content view version and lifecycle environment.")
+    param :status, [:enabled, :disabled, :overridden],
+                                  :desc => N_("Limit content to enabled / disabled / overridden"),
+                                  :required => false
+
     param_group :search, Api::V2::ApiController
     add_scoped_search_description_for(Katello::ProductContent)
     def index
       collection = scoped_search(index_relation, :name, :asc, :resource_class => Katello::ProductContent)
-      collection[:results] = ProductContentFinder.wrap_with_overrides(
-          product_contents: collection[:results],
-          overrides: @consumable&.content_overrides)
+      pcf = ProductContentFinder.wrap_with_overrides(
+        product_contents: collection[:results],
+        overrides: @consumable&.content_overrides,
+        status: params[:status])
+      collection[:results] = custom_sort_results(pcf)
       respond(:collection => collection)
     end
 
@@ -100,6 +106,7 @@ module Katello
     api :PUT, "/repository_sets/:id/disable", N_("Disable a repository from the set")
     api :PUT, "/products/:product_id/repository_sets/:id/disable", N_("Disable a repository from the set")
     param :id, :number, :required => true, :desc => N_("ID of the repository set to disable")
+    param :repository_id, :number, :required => false, :desc => N_("ID of the repository within the set to disable")
     param :product_id, :number, :required => false, :desc => N_("ID of the product containing the repository set")
     param :basearch, String, :required => false, :desc => N_("Basearch to disable")
     param :releasever, String, :required => false, :desc => N_("Releasever to disable")
@@ -186,7 +193,7 @@ module Katello
     end
 
     def substitutions
-      params.permit(:basearch, :releasever).to_h
+      params.permit(:basearch, :releasever, :repository_id).to_h
     end
 
     def find_authorized_activation_key
@@ -212,8 +219,34 @@ module Katello
     end
 
     def check_airgapped
-      if @organization.cdn_configuration.airgapped?
-        respond_for_index(:collection => { :error => _("Repositories are not available for enablement while CDN configuration is set to Air-gapped (disconnected).") }, :status => :forbidden)
+      if @organization.cdn_configuration.export_sync?
+        fail HttpErrors::BadRequest, _("Repositories are not available for enablement while CDN configuration is set to Air-gapped (disconnected).")
+      end
+    end
+
+    def sort_score(pc) # sort order for enabled
+      score = if pc.enabled_content_override&.value == "1"
+                4 # overridden to enabled
+              elsif pc.enabled_content_override.nil? && pc.enabled
+                3 # enabled
+              elsif pc.enabled_content_override.nil? && !pc.enabled
+                2 # disabled
+              elsif pc.enabled_content_override&.value == "0"
+                1 # overridden to disabled
+              else
+                0
+              end
+      Rails.logger.debug [pc.product_name, pc.enabled_content_override, "Id: #{pc.id}", "Score: #{score}"]
+      score
+    end
+
+    def custom_sort_results(product_content_finder)
+      if params[:sort_by] == 'enabled_by_default' && params[:sort_order] == 'desc'
+        product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }.reverse!
+      elsif params[:sort_by] == 'enabled_by_default'
+        product_content_finder.sort { |pca, pcb| sort_score(pca) <=> sort_score(pcb) }
+      else
+        product_content_finder
       end
     end
   end

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

@@ -43,11 +43,11 @@ module Katello
           collection = scoped_search(*base_args, options)
           csv_response(collection,
                        [:id, :subscription_id, :name, :cp_id, :organization_id, :sockets, :cores,
-                        :start_date, :end_date, :available, :quantity, :account_number, :contract_number,
+                        :start_date, :end_date, :consumed, :quantity, :account_number, :contract_number,
                         :support_level, :ram, :stacking_id, :multi_entitlement, :type, :product_id,
                         :unmapped_guest, :virt_only, :virt_who, :upstream?],
                        ['Pool Id Number', 'Subscription Id', 'Name', 'Pool Id', 'Organization Id',
-                        'Sockets', 'Cores', 'Start Date', 'End Date', 'Available', 'Quantity', 'Account Number',
+                        'Sockets', 'Cores', 'Start Date', 'End Date', 'Consumed', 'Quantity', 'Account Number',
                         'Contract Number', 'Support Level', 'RAM', 'Stacking Id', 'Multi Entitlement', 'Type',
                         'Product Id', 'Unmapped Guest', 'Virt Only', 'Requires Virt Who', 'Upstream'])
         end

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

@@ -24,7 +24,7 @@ module Katello
           process_response(:object => @host)
         end
 
-        api :PUT, "/hosts/:host_id/host_collections", N_("Alter a hosts host collections")
+        api :PUT, "/hosts/:host_id/host_collections", N_("Alter a host's host collections")
         param :host_id, :number, :required => true, :desc => N_("The id of the host to alter")
         param :host_collection_ids, Array, :required => true, :desc => N_("List of host collection ids to update")
         def host_collections

data/app/helpers/katello/concerns/smart_proxy_helper_extensions.rb

@@ -35,6 +35,10 @@ module Katello
             :name => _("Immediate"),
             :label => ::Katello::RootRepository::DOWNLOAD_IMMEDIATE
           },
+          {
+            :name => _("Streamed"),
+            :label => SmartProxy::DOWNLOAD_STREAMED
+          },
           {
             :name => _("Inherit from Repository"),
             :label => SmartProxy::DOWNLOAD_INHERIT

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -205,9 +205,7 @@ module Katello
         return [] unless new_host.operatingsystem.is_a?(Redhat)
 
         if (host.is_a? ::Hostgroup)
-          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)
+          new_host.content_facet = hostgroup_content_facet(host, param_host)
         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,
@@ -270,5 +268,25 @@ module Katello
     def hosts_change_content_source
       [{ action: [_('Change Content Source'), '/change_host_content_source', false], priority: 100 }]
     end
+
+    private
+
+    def hostgroup_content_facet(hostgroup, param_host)
+      lifecycle_environment_id = hostgroup.inherited_lifecycle_environment_id
+      content_view_id = hostgroup.inherited_content_view_id
+      content_source_id = hostgroup.inherited_content_source_id
+      if param_host.lifecycle_environment_id && (hostgroup.inherited_lifecycle_environment_id != param_host.lifecycle_environment_id)
+        lifecycle_environment_id = param_host.lifecycle_environment_id
+      end
+      if param_host.content_view_id && (hostgroup.inherited_content_view_id != param_host.content_view_id)
+        content_view_id = param_host.content_view_id
+      end
+      if param_host.content_source_id && (hostgroup.inherited_content_source_id != param_host.content_source_id)
+        content_source_id = param_host.content_source_id
+      end
+      ::Katello::Host::ContentFacet.new(:lifecycle_environment_id => lifecycle_environment_id,
+                                        :content_view_id => content_view_id,
+                                        :content_source_id => content_source_id)
+    end
   end
 end

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

@@ -0,0 +1,24 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Create < Actions::EntryAction
+        def plan(acs, smart_proxies)
+          acs.save!
+          action_subject(acs)
+          smart_proxies = smart_proxies.uniq
+          concurrence do
+            smart_proxies.each do |smart_proxy|
+              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
+                          acs, smart_proxy)
+            end
+          end
+        end
+
+        def humanized_name
+          _("Create Alternate Content Source")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Destroy < Actions::EntryAction
+        def plan(acs)
+          action_subject(acs)
+          sequence do
+            acs.smart_proxies.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
+                          acs, smart_proxy)
+            end
+            plan_self(:acs_id => acs.id)
+          end
+        end
+
+        def finalize
+          acs = ::Katello::AlternateContentSource.find_by(id: input[:acs_id])
+          acs.destroy
+        end
+
+        def humanized_name
+          _("Destroy Alternate Content Source")
+        end
+      end
+    end
+  end
+end

data/app/lib/actions/katello/alternate_content_source/refresh.rb

@@ -0,0 +1,27 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Refresh < Actions::EntryAction
+        def plan(acs)
+          action_subject(acs)
+          concurrence do
+            acs.smart_proxies.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Refresh,
+                          acs, smart_proxy)
+            end
+          end
+          plan_self(acs_id: acs.id)
+        end
+
+        def finalize
+          acs = ::Katello::AlternateContentSource.find_by(id: input[:acs_id])
+          acs.update(last_refreshed: ::DateTime.now)
+        end
+
+        def humanized_name
+          _("Refresh Alternate Content Source")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Actions
+  module Katello
+    module AlternateContentSource
+      class Update < Actions::EntryAction
+        # smart_proxies ALWAYS represents the smart proxies to remain associated
+        # after the action runs.  If smart_proxies == [], there will be none afterwards.
+        def plan(acs, smart_proxies, acs_params)
+          action_subject(acs)
+          acs.update!(acs_params)
+
+          smart_proxies = smart_proxies.uniq
+          smart_proxies_to_add = smart_proxies - acs.smart_proxies
+          smart_proxies_to_delete = acs.smart_proxies - smart_proxies
+          smart_proxies_to_update = smart_proxies & acs.smart_proxies
+
+          concurrence do
+            smart_proxies_to_add&.each do |smart_proxy|
+              ::Katello::SmartProxyAlternateContentSource.create(alternate_content_source_id: acs.id, smart_proxy_id: smart_proxy.id)
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Create,
+                          acs, smart_proxy)
+            end
+
+            smart_proxies_to_delete&.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Delete,
+                          acs, smart_proxy)
+            end
+
+            smart_proxies_to_update&.each do |smart_proxy|
+              plan_action(Pulp3::Orchestration::AlternateContentSource::Update,
+                          acs, smart_proxy)
+            end
+          end
+        end
+
+        def humanized_name
+          _("Update Alternate Content Source")
+        end
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Actions
         def plan(cdn_configuration, options)
           cdn_configuration.update!(options)
 
-          if cdn_configuration.upstream_server?
+          if cdn_configuration.network_sync?
             resource = ::Katello::Resources::CDN::CdnResource.create(cdn_configuration: cdn_configuration)
             resource.validate!
             keypair = resource.debug_certificate
@@ -20,8 +20,8 @@ module Actions
           roots.each do |root|
             full_path = if cdn_configuration.redhat_cdn?
                           root.product.repo_url(root.library_instance.generate_content_path)
-                        elsif cdn_configuration.upstream_server?
-                          resource.repository_url(content_label: root.content.label)
+                        elsif cdn_configuration.network_sync?
+                          resource.repository_url(content_label: root.content.label, arch: root.arch, major: root.major, minor: root.minor)
                         end
             plan_action(::Actions::Katello::Repository::Update, root, url: full_path)
           end

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

@@ -25,7 +25,8 @@ module Actions
         end
 
         def finalize
-          content_view = ::Katello::ContentView.find(input[:content_view][:id])
+          content_view = ::Katello::ContentView.where(id: input[:content_view][:id]).first
+          return if content_view.blank?
           content_view.content_view_repositories.each(&:destroy)
           content_view.destroy!
         end

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

@@ -13,6 +13,11 @@ module Actions
             concurrence do
               version_environments.each do |version_environment|
                 version = version_environment[:content_view_version]
+                if version.content_view.generated?
+                  fail _("Cannot perform an incremental update on a Generated Content View Version (%{name} version version %{version}") %
+                    {:name => version.content_view.name, :version => version.version}
+                end
+
                 if version.content_view.composite?
                   fail _("Cannot perform an incremental update on a Composite Content View Version (%{name} version version %{version}") %
                     {:name => version.content_view.name, :version => version.version}
@@ -53,9 +58,8 @@ module Actions
 
               action = plan_action(ContentViewVersion::IncrementalUpdate, composite_version, environments,
                                    :new_components => new_components, :description => description)
-              unless SmartProxy.pulp_primary.pulp3_repository_type_support?("yum")
-                output_for_version_ids << {:version_id => action.new_content_view_version.id, :output => action.output}
-              end
+
+              output_for_version_ids << {:version_id => action.new_content_view_version_id, :output => action.output}
             end
           end
         end

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

@@ -41,7 +41,7 @@ module Actions
                                                           :triggered_by => options[:triggered_by]
                                                          )
           source_repositories = []
-          content_view.publish_repositories(options[:override_cvvs]) do |repositories|
+          content_view.publish_repositories(options[:override_components]) do |repositories|
             source_repositories += [repositories]
           end
 
@@ -90,19 +90,13 @@ module Actions
         end
 
         def run
-          metadata = {
-            description: _("Auto Publish - Triggered by '%s'") % input[:content_view_version_name],
-            triggered_by: input[:content_view_version_id]
-          }
-          input[:auto_publish_composite_ids].each do |composite_id|
-            ::Katello::EventQueue.push_event(::Katello::Events::AutoPublishCompositeView::EVENT_TYPE, composite_id) do |attrs|
-              attrs[:metadata] = metadata
-            end
-          end
+          version = ::Katello::ContentViewVersion.find(input[:content_view_version_id])
+          version.auto_publish_composites!
 
           output[:content_view_id] = input[:content_view_id]
           output[:content_view_version_id] = input[:content_view_version_id]
           output[:skip_promotion] = input[:skip_promotion]
+          output[:history_id] = input[:history_id]
         end
 
         def rescue_strategy_for_self
@@ -142,6 +136,10 @@ module Actions
           input['content_view_version_name']
         end
 
+        def history_id
+          input['history_id']
+        end
+
         private
 
         def include_other_components(override_components, content_view)

data/app/lib/actions/katello/content_view_version/auto_create_products.rb

@@ -2,14 +2,14 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateProducts < Actions::Base
-        def plan(organization:, metadata:)
+        def plan(import:)
           helper = ::Katello::Pulp3::ContentViewVersion::ImportableProducts.
-                      new(organization: organization,
-                          metadata: metadata)
+                      new(organization: import.organization,
+                          metadata_products: import.metadata_map.products)
           helper.generate!
           concurrence do
             helper.creatable.each do |product|
-              plan_action(::Actions::Katello::Product::Create, product[:product], organization)
+              plan_action(::Actions::Katello::Product::Create, product[:product], import.organization)
             end
             helper.updatable.each do |product|
               plan_action(::Actions::Katello::Product::Update, product[:product], product[:options])

data/app/lib/actions/katello/content_view_version/auto_create_redhat_repositories.rb

@@ -2,11 +2,13 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRedhatRepositories < Actions::Base
-        def plan(organization:, metadata:)
-          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.
-                      new(organization: organization,
-                      metadata: metadata, redhat: true)
+        def plan(import:)
+          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
+            organization: import.organization,
+            metadata_repositories: import.metadata_map.repositories.select { |r| r.redhat }
+          )
           helper.generate!
+
           sequence do
             helper.creatable.each do |root|
               plan_action(::Actions::Katello::RepositorySet::EnableRepository, root[:product], root[:content], root[:substitutions])

data/app/lib/actions/katello/content_view_version/auto_create_repositories.rb

@@ -2,11 +2,13 @@ module Actions
   module Katello
     module ContentViewVersion
       class AutoCreateRepositories < Actions::Base
-        def plan(organization:, metadata:)
-          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.
-                      new(organization: organization,
-                          metadata: metadata)
+        def plan(import:)
+          helper = ::Katello::Pulp3::ContentViewVersion::ImportableRepositories.new(
+            organization: import.organization,
+            metadata_repositories: import.metadata_map.repositories.select { |r| !r.redhat }
+          )
           helper.generate!
+
           sequence do
             helper.creatable.each do |root|
               plan_action(::Actions::Katello::Repository::CreateRoot, root[:repository])

data/app/lib/actions/katello/content_view_version/import.rb

@@ -2,38 +2,41 @@ module Actions
   module Katello
     module ContentViewVersion
       class Import < Actions::EntryAction
-        def plan(organization:, path:, metadata:, library: false)
-          fail _("Content view not provided in the metadata") if metadata[:content_view].blank?
-          content_view = ::Katello::Pulp3::ContentViewVersion::Import.
-                                find_or_create_import_view(organization: organization,
-                                                           metadata: metadata[:content_view],
-                                                           library: library)
-          content_view.check_ready_to_import!
-          ::Katello::Pulp3::ContentViewVersion::Import.check!(content_view: content_view,
-                                                              metadata: metadata,
-                                                              path: path,
-                                                              smart_proxy: SmartProxy.pulp_primary!)
+        def plan(organization:, path:, metadata:)
+          metadata_map = ::Katello::Pulp3::ContentViewVersion::MetadataMap.new(metadata: metadata)
 
-          major = metadata[:content_view_version][:major]
-          minor = metadata[:content_view_version][:minor]
-          description = metadata[:content_view_version][:description]
+          import = ::Katello::Pulp3::ContentViewVersion::Import.new(
+            organization: organization,
+            metadata_map: metadata_map,
+            path: path,
+            smart_proxy: SmartProxy.pulp_primary!
+          )
+
+          import.check!
 
           gpg_helper = ::Katello::Pulp3::ContentViewVersion::ImportGpgKeys.
                           new(organization: organization,
-                              metadata: metadata)
+                              metadata_gpg_keys: metadata_map.gpg_keys)
           gpg_helper.import!
 
           sequence do
-            plan_action(AutoCreateProducts, organization: content_view.organization, metadata: metadata)
-            plan_action(AutoCreateRepositories, organization: content_view.organization, metadata: metadata)
-            plan_action(AutoCreateRedhatRepositories, organization: content_view.organization, metadata: metadata)
-            plan_action(ResetContentViewRepositoriesFromMetadata, content_view: content_view, metadata: metadata)
-            plan_action(::Actions::Katello::ContentView::Publish, content_view, description,
+            plan_action(AutoCreateProducts, import: import)
+            plan_action(AutoCreateRepositories, import: import)
+            plan_action(AutoCreateRedhatRepositories, import: import)
+            plan_action(ResetContentViewRepositoriesFromMetadata, import: import)
+            plan_action(::Actions::Katello::ContentView::Publish, import.content_view, metadata_map.content_view_version.description,
                           path: path,
                           metadata: metadata,
                           importing: true,
-                          major: major,
-                          minor: minor)
+                          major: metadata_map.content_view_version.major,
+                          minor: metadata_map.content_view_version.minor)
+            plan_self(content_view_id: import.content_view.id)
+          end
+        end
+
+        def finalize
+          if task.execution_plan.run_steps.any? { |s| s.action_class == ::Actions::Pulp3::ContentViewVersion::CreateImport && s.state != :success }
+            ::Katello::EventQueue.push_event(::Katello::Events::DeleteLatestContentViewVersion::EVENT_TYPE, input[:content_view_id])
           end
         end
 

data/app/lib/actions/katello/content_view_version/import_library.rb

@@ -5,7 +5,6 @@ module Actions
         def plan(organization, path:, metadata:)
           action_subject(organization)
           plan_action(::Actions::Katello::ContentViewVersion::Import, organization: organization,
-                                                                      library: true,
                                                                       path: path,
                                                                       metadata: metadata)
         end

data/app/lib/actions/katello/content_view_version/import_repository.rb

@@ -0,0 +1,21 @@
+module Actions
+  module Katello
+    module ContentViewVersion
+      class ImportRepository < Actions::EntryAction
+        def plan(organization, path:, metadata:)
+          action_subject(organization)
+          sequence do
+            plan_action(::Actions::Katello::ContentViewVersion::Import,
+                                            organization: organization,
+                                            path: path,
+                                            metadata: metadata)
+          end
+        end
+
+        def humanized_name
+          _("Import Repository")
+        end
+      end
+    end
+  end
+end