katello 3.5.2 → 3.6.0.rc1

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

@@ -4,7 +4,7 @@ module Katello
       def disks(storage)
         mount_points = {}
         disks = []
-        storage.each do |_name, values|
+        storage.each_value do |values|
           mount = values['mounted']
           mount_points[mount].nil? ? mount_points[mount] = [values['path']] : mount_points[mount] << values['path']
           values['header'] = "#{mount_points[mount].to_sentence} (on #{values['filesystem']})"

data/app/helpers/katello/hosts_and_hostgroups_helper.rb

@@ -86,9 +86,7 @@ module Katello
     def fetch_content_view(host, options = {})
       selected_host_group = options.fetch(:selected_host_group, nil)
       return content_view(selected_host_group) if selected_host_group.present?
-
-      selected_content_view = content_view(host)
-      selected_content_view if selected_content_view.present?
+      content_view(host)
     end
 
     def accessible_lifecycle_environments(org, host)

data/app/helpers/katello/providers_helper.rb

@@ -20,11 +20,8 @@ module Katello
       tabs = {}.with_indifferent_access
       redhat_repo_tabs.each { |tab| tabs[tab[:id]] = tab }
 
-      product_content = provider.organization.filtered_product_content
-
-      provider.products.each do |product|
-        selected_contents = product_content.select { |pc| pc.product_id == product.id }.select(&:displayable?)
-        selected_contents.each do |prod_content|
+      provider.products.includes(:displayable_product_contents).each do |product|
+        product.displayable_product_contents.each do |prod_content|
           name = prod_content.content.name
           if prod_content.content_type == ::Katello::Repository::CANDLEPIN_OSTREE_TYPE
             key = :ostree

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

@@ -28,6 +28,8 @@ module Actions
     end
 
     class ListenOnCandlepinEvents < Actions::Base
+      include ::Dynflow::Action::Singleton
+
       Connected = Algebrick.atom
 
       Reconnect = Algebrick.type do
@@ -44,21 +46,12 @@ module Actions
 
       Close = Algebrick.atom
 
-      class RunOnceCoordinatorLock < Dynflow::Coordinator::LockByWorld
-        def initialize(world)
-          super
-          @data[:id] = 'listen-on-candlepin-events'
-        end
-      end
-
       class << self
         attr_reader :triggered_action
 
         def ensure_running(world = ForemanTasks.dynflow.world)
-          world.coordinator.acquire(RunOnceCoordinatorLock.new(world)) do
-            unless ForemanTasks::Task::DynflowTask.for_action(self).running.any?
-              @triggered_action = ForemanTasks.trigger(self)
-            end
+          unless self.singleton_locked?(world)
+            @triggered_action = ForemanTasks.trigger self
           end
         rescue Dynflow::Coordinator::LockError
           return false
@@ -67,9 +60,6 @@ module Actions
 
       def plan
         # Make sure we don't have two concurrent listening services competing
-        if already_running?
-          fail "Action #{self.class.name} is already active"
-        end
         plan_self
       end
 
@@ -182,7 +172,7 @@ module Actions
           output[:connection] = "Connected"
           Actions::Candlepin::ImportPoolHandler.new(Rails.logger).handle(event)
           output[:last_message] = "#{event.message_id} - #{event.subject}"
-          output[:last_message_time] = DateTime.now.to_s
+          output[:last_message_time] = Time.now.to_s
           output[:messages] = event.message_id
         rescue => e
           output[:last_event_error] = e.message

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

@@ -18,6 +18,7 @@ module Actions
           ["'#{input['smart_proxy']['name']}'"] + super
         end
 
+        # rubocop:disable MethodLength
         def plan(smart_proxy, options = {})
           action_subject(smart_proxy)
           capsule_content = ::Katello::CapsuleContent.new(smart_proxy)
@@ -73,6 +74,13 @@ module Actions
                               capsule_id: capsule_content.capsule.id,
                               force: true)
                 end
+                if repo.is_a?(::Katello::Repository) &&
+                   repo.distribution_bootable? &&
+                   repo.download_policy == ::Runcible::Models::YumImporter::DOWNLOAD_ON_DEMAND
+                  plan_action(Katello::Repository::FetchPxeFiles,
+                              id: repo.id,
+                              capsule_id: capsule_content.capsule.id)
+                end
               end
             end
           end

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

@@ -74,7 +74,7 @@ module Actions
 
         def total_counts(input)
           total_count = {}
-          if input[:version_outputs]
+          if input && input[:version_outputs]
             content_view_count = input[:version_outputs].length
             input[:version_outputs].map do |version_output|
               added_units = version_output.try(:[], :output).try(:[], :added_units)

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

@@ -61,7 +61,7 @@ module Actions
         def find_or_build_puppet_env(version, environment, puppet_modules_present)
           puppet_env = ::Katello::ContentViewPuppetEnvironment.in_content_view(version.content_view).
               in_environment(environment).readonly(false).first
-          puppet_env = version.content_view.build_puppet_env(:environment => environment) unless puppet_env
+          puppet_env ||= version.content_view.build_puppet_env(:environment => environment)
 
           if puppet_env.puppet_environment.nil? && puppet_modules_present
             puppet_env.puppet_environment = ::Katello::Foreman.build_puppet_environment(version.content_view.organization,
@@ -72,7 +72,7 @@ module Actions
 
         def find_or_build_puppet_archive(new_version)
           puppet_env = new_version.archive_puppet_environment
-          puppet_env = new_version.content_view.build_puppet_env(:version => new_version) unless puppet_env
+          puppet_env ||= new_version.content_view.build_puppet_env(:version => new_version)
           puppet_env
         end
       end

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

@@ -5,10 +5,7 @@ module Actions
         def plan(content_view_version)
           action_subject(content_view_version.content_view)
           plan_self(:version_id => content_view_version.id)
-
-          content_view_version.repositories.each do |repo|
-            plan_action(::Actions::Katello::Repository::MetadataGenerate, repo, :force => true)
-          end
+          plan_action(::Actions::Katello::Repository::BulkMetadataGenerate, content_view_version.repositories, :force => true)
 
           content_view_version.content_view_puppet_environments.each do |repo|
             plan_action(::Actions::Katello::Repository::MetadataGenerate, repo, :force => true)
@@ -24,7 +21,7 @@ module Actions
         end
 
         def humanized_name
-          if input[:version_id]
+          if input && input[:version_id]
             version = ::Katello::ContentViewVersion.find_by(:id => input[:version_id])
           end
 

data/app/lib/actions/katello/event_queue/monitor.rb

@@ -2,8 +2,10 @@ module Actions
   module Katello
     module EventQueue
       class Monitor < Actions::Base
+        include ::Dynflow::Action::Singleton
+
         Event = Algebrick.type do
-          fields! event_type: String, object_id: Integer, created_at: DateTime
+          fields! event_type: String, object_id: Integer, created_at: Time
         end
 
         Fatal = Algebrick.type do
@@ -13,23 +15,20 @@ module Actions
         Ready = Algebrick.atom
         Close = Algebrick.atom
 
-        cattr_accessor :triggered_action
+        class << self
+          attr_reader :triggered_action
 
-        def self.ensure_running(world = ForemanTasks.dynflow.world)
-          world.coordinator.acquire(RunOnceCoordinatorLock.new(world)) do
-            unless ForemanTasks::Task::DynflowTask.for_action(self).running.any?
-              self.triggered_action = ForemanTasks.trigger(self)
+          def ensure_running(world = ForemanTasks.dynflow.world)
+            unless self.singleton_locked?(world)
+              @triggered_action = ForemanTasks.trigger self
             end
+          rescue Dynflow::Coordinator::LockError
+            return false
           end
-        rescue Dynflow::Coordinator::LockError
-          return false
         end
 
         def plan
           # Make sure we don't have two concurrent listening services competing
-          if already_running?
-            fail "Action #{self.class.name} is already active"
-          end
           plan_self
         end
 

data/app/lib/actions/katello/event_queue/suspended_action.rb

@@ -7,7 +7,7 @@ module Actions
         end
 
         def notify_queue_item(event_type, object_id, created_at)
-          @suspended_action << Monitor::Event[event_type, object_id, created_at.to_datetime]
+          @suspended_action << Monitor::Event[event_type, object_id, created_at]
         end
 
         def notify_ready

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

@@ -113,7 +113,7 @@ module Actions
 
         def plan_subscription_facet(host, activation_keys, consumer_params)
           subscription_facet = host.subscription_facet || ::Katello::Host::SubscriptionFacet.new(:host => host)
-          subscription_facet.last_checkin = DateTime.now
+          subscription_facet.last_checkin = Time.now
           subscription_facet.update_from_consumer_attributes(consumer_params.except(:installedProducts, :guestIds, :facts))
           subscription_facet.save!
           subscription_facet.activation_keys = activation_keys

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

@@ -10,9 +10,7 @@ module Actions
             host.content_facet.save! if host.content_facet
 
             if host.subscription_facet
-              unless consumer_params
-                consumer_params = host.subscription_facet.consumer_attributes
-              end
+              consumer_params ||= host.subscription_facet.consumer_attributes
               cp_update = plan_action(::Actions::Candlepin::Consumer::Update, host.subscription_facet.uuid, consumer_params)
             end
 

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

@@ -12,13 +12,9 @@ module Actions
           upstream = details['upstreamConsumer'].blank? ? {} : details['upstreamConsumer']
 
           sequence do
-            regen_certs = plan_action(Candlepin::Owner::UpstreamRegenerateCertificates,
-                        :organization_id => organization.id,
-                        :upstream => upstream)
             upstream_update = plan_action(Candlepin::Owner::UpstreamUpdate,
                         :organization_id => organization.id,
-                        :upstream => upstream,
-                        :dependency => regen_certs.output)
+                        :upstream => upstream)
             export_action = plan_action(Candlepin::Owner::UpstreamExport,
                         :organization_id => organization.id,
                         :upstream => upstream,

data/app/lib/actions/katello/product/content_create.rb

@@ -6,7 +6,7 @@ module Actions
 
         def plan(repository)
           sequence do
-            if repository.content.nil?
+            if repository.content_id.nil?
               content_create = plan_action(Candlepin::Product::ContentCreate,
                                            owner:       repository.product.organization.label,
                                            name:        repository.name,
@@ -43,6 +43,16 @@ module Actions
           repository = ::Katello::Repository.find(input[:repository_id])
           repository.content_id = input[:content_id]
           repository.save!
+
+          content = ::Katello::Content.create!(name: repository.name,
+                                               cp_content_id: repository.content_id,
+                                               content_type: repository.content_type,
+                                               label: repository.custom_content_label,
+                                               content_url: content_url(repository),
+                                               vendor: ::Katello::Provider::CUSTOM)
+
+          #custom product content is always enabled by default
+          ::Katello::ProductContent.create!(product: repository.product, content: content, enabled: true)
         end
 
         private

data/app/lib/actions/katello/product/content_destroy.rb

@@ -9,10 +9,18 @@ module Actions
                         owner: repository.product.organization.label,
                         product_id: repository.product.cp_id,
                         content_id: repository.content_id)
+
+            katello_content_id = repository.product.product_content_by_id(repository.content_id).content_id
+
+            ::Katello::ProductContent.where(product_id: repository.product_id,
+                                            content_id: katello_content_id).destroy_all
+
             if repository.other_repos_with_same_content.empty?
               plan_action(Candlepin::Product::ContentDestroy,
                           owner: repository.product.organization.label,
                           content_id: repository.content_id)
+
+              ::Katello::Content.find(katello_content_id).destroy!
             end
           end
         end

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

@@ -20,7 +20,7 @@ module Actions
           # Candlepin::Product::ContentRemove is called with Katello::Repository::Destroy, so we only want to run ContentRemove
           # on repos that are not being destroyed with Katello::Repository::Destroy.
           content_ids = product.repositories.in_default_view.map(&:content_id)
-          remaining_product_content = product.productContent.select { |content| !content_ids.include? content.content.id }
+          remaining_product_content = product.product_contents.select { |content| !content_ids.include?(content.content.cp_content_id) }
 
           sequence do
             unless organization_destroy
@@ -43,7 +43,7 @@ module Actions
                   plan_action(Candlepin::Product::ContentRemove,
                               owner: product.organization.label,
                               product_id: product.cp_id,
-                              content_id: pc.content.id)
+                              content_id: pc.content.cp_content_id)
                 end
                 plan_action(Candlepin::Product::Destroy, cp_id: product.cp_id, :owner => product.organization.label)
               end

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

@@ -9,9 +9,6 @@ module Actions
             plan_action(::Actions::Katello::Product::RepositoriesGpgReset, product)
           end
 
-          if ::SETTINGS[:katello][:use_cp] && product.productContent_changed?
-            plan_action(::Actions::Candlepin::Product::Update, product)
-          end
           plan_action(::Actions::Pulp::Repos::Update, product) if ::SETTINGS[:katello][:use_pulp]
         end
       end

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

@@ -0,0 +1,15 @@
+module Actions
+  module Katello
+    module Repository
+      class BulkMetadataGenerate < Actions::Base
+        def plan(repos, options = {})
+          sequence do
+            plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::MetadataGenerate, repos.in_default_view, options) if repos.in_default_view.any?
+            plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::MetadataGenerate, repos.archived, options) if repos.archived.any?
+            plan_action(::Actions::BulkAction, ::Actions::Katello::Repository::MetadataGenerate, repos.in_published_environments, options) if repos.in_published_environments.any?
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,12 +14,19 @@ module Actions
           source_repo = ::Katello::Repository.find(input[:source_repo_id])
           target_repo = ::Katello::Repository.find(input[:target_repo_id])
 
+          srpms_match = srpms_match?(source_repo, target_repo)
           rpms = rpms_match?(source_repo, target_repo)
           errata = errata_match?(source_repo, target_repo)
           package_groups = package_groups_match?(source_repo, target_repo)
           distributions = distributions_match?(source_repo, target_repo)
 
-          output[:matching_content] = rpms && errata && package_groups && distributions && target_repo.published?
+          output[:matching_content] = srpms_match && rpms && errata && package_groups && distributions && target_repo.published?
+        end
+
+        def srpms_match?(source_repo, target_repo)
+          source_repo_ids = source_repo.srpm_ids.sort
+          target_repo_ids = target_repo.srpm_ids.sort
+          source_repo_ids == target_repo_ids
         end
 
         def rpms_match?(source_repo, target_repo)
@@ -35,8 +42,8 @@ module Actions
         end
 
         def package_groups_match?(source_repo, target_repo)
-          source_repo_ids = source_repo.package_group_ids.sort
-          target_repo_ids = target_repo.package_group_ids.sort
+          source_repo_ids = source_repo.package_groups.order(:name).pluck(:name)
+          target_repo_ids = target_repo.package_groups.order(:name).pluck(:name)
           source_repo_ids == target_repo_ids
         end
 

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

@@ -10,7 +10,10 @@ module Actions
            Pulp::Repository::RemoveYumMetadataFile,
            Pulp::Repository::RemoveFile,
            Pulp::Repository::RemovePuppetModule,
-           Pulp::Repository::RemoveDockerManifest].each do |action_class|
+           Pulp::Repository::RemoveDockerManifest,
+           Pulp::Repository::RemoveDockerManifestList,
+           Pulp::Repository::RemoveDockerTag,
+           Pulp::Repository::RemoveDockerBlob].each do |action_class|
             plan_action(action_class, pulp_id: repo.pulp_id)
           end
         end

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

@@ -0,0 +1,70 @@
+module Actions
+  module Katello
+    module Repository
+      class CloneDebContent < Actions::Base
+        # rubocop:disable MethodLength
+        def plan(source_repo, target_repo, filters, _purge_empty_units, options = {})
+          generate_metadata = options.fetch(:generate_metadata, true)
+          index_content = options.fetch(:index_content, true)
+
+          copy_clauses = nil
+          remove_clauses = nil
+          filters = filters.deb unless filters.is_a? Array
+
+          if filters.any?
+            clause_gen = ::Katello::Util::PackageClauseGenerator.new(source_repo, filters)
+            clause_gen.generate
+            copy_clauses = clause_gen.copy_clause
+            remove_clauses = clause_gen.remove_clause
+          end
+
+          sequence do
+            if filters.empty? || copy_clauses
+              plan_copy(Pulp::Repository::CopyDeb, source_repo, target_repo, copy_clauses)
+            elsif options[:simple_clone]
+              plan_copy(Pulp::Repository::CopyDeb, source_repo, target_repo)
+            end
+            if remove_clauses
+              plan_remove(Pulp::Repository::RemoveDeb, target_repo, :unit => remove_clauses)
+            end
+            plan_copy(Pulp::Repository::CopyDebRelease, source_repo, target_repo)
+            plan_copy(Pulp::Repository::CopyDebComponent, source_repo, target_repo)
+
+            # Check for matching content before indexing happens, the content in pulp is
+            # actually updated, but it is not reflected in the database yet.
+            output = {}
+            if target_repo.environment && !options[:force_yum_metadata_regeneration]
+              output = plan_action(Katello::Repository::CheckMatchingContent,
+                                   :source_repo_id => source_repo.id,
+                                   :target_repo_id => target_repo.id).output
+            end
+
+            plan_action(Katello::Repository::IndexContent, id: target_repo.id) if index_content
+
+            source_repository = filters.empty? ? source_repo : nil
+
+            if generate_metadata
+              plan_action(Katello::Repository::MetadataGenerate,
+                          target_repo,
+                          :source_repository => source_repository,
+                          :matching_content => output[:matching_content])
+            end
+          end
+        end
+
+        def plan_copy(action_class, source_repo, target_repo, clauses = nil)
+          plan_action(action_class,
+                      source_pulp_id: source_repo.pulp_id,
+                      target_pulp_id: target_repo.pulp_id,
+                      clauses:        clauses)
+        end
+
+        def plan_remove(action_class, target_repo, clauses)
+          plan_action(action_class,
+                      pulp_id:        target_repo.pulp_id,
+                      clauses:        clauses)
+        end
+      end
+    end
+  end
+end