fixes #7890 Move Distributions from Elasticsearch to the Database

app/lib/actions/katello/foreman/content_update.rb

@@ -20,11 +20,10 @@ def finalize
           content_view = ::Katello::ContentView.find(input[:content_view_id])
           repository = ::Katello::Repository.find(input[:repository_id]) if input[:repository_id]
 
-          if content_view.default?
-            if distribution = repository.try(:bootable_distribution)
-              os = Redhat.find_or_create_operating_system(distribution)
-
-              arch = Architecture.where(:name => distribution.arch).first_or_create!
+          if content_view.default? && repository
+            if repository.distribution_bootable?
+              os = Redhat.find_or_create_operating_system(repository)
+              arch = Architecture.where(:name => repository.distribution_arch).first_or_create!
               os.architectures << arch unless os.architectures.include?(arch)
             end
           else

app/lib/katello/util/search.rb

@@ -53,8 +53,7 @@ def self.backend_search_classes
       end
 
       def self.pulp_backend_search_classes
-        [Katello::PuppetModule,
-         Katello::Distribution]
+        [Katello::PuppetModule]
       end
 
       def self.get_subclasses(obj_class)

app/models/katello/concerns/medium_extensions.rb

@@ -16,12 +16,12 @@ def update_media(repo)
 
           medium_path = ::Medium.installation_media_path(repo.uri)
 
-          if distribution = repo.bootable_distribution
+          if distribution = repo.distribution_bootable?
             return if ::Medium.find_by_path(medium_path)
 
-            os = ::Redhat.find_or_create_operating_system(distribution)
+            os = ::Redhat.find_or_create_operating_system(repo)
 
-            arch = ::Architecture.where(:name => distribution.arch).first_or_create!
+            arch = ::Architecture.where(:name => repo.distribution_arch).first_or_create!
             os.architectures << arch unless os.architectures.include?(arch)
 
             medium_name = ::Medium.construct_name(repo, distribution)

app/models/katello/concerns/redhat_extensions.rb

@@ -10,9 +10,9 @@ module RedhatExtensions
       end
 
       module ClassMethods
-        def find_or_create_operating_system(distribution)
-          os_name = construct_name(distribution.family)
-          major, minor = distribution.version.split('.')
+        def find_or_create_operating_system(repo)
+          os_name = construct_name(repo.distribution_family)
+          major, minor = repo.distribution_version.split('.')
           minor ||= '' # treat minor versions as empty string to not confuse with nil
 
           create_os = lambda { ::Redhat.where(:name => os_name, :major => major, :minor => minor).first_or_create! }
@@ -64,20 +64,10 @@ def distribution_repositories(host)
         lifecycle_environment = host.lifecycle_environment
 
         if content_view && lifecycle_environment
-          version = content_view.version(lifecycle_environment)
-          repo_ids = version.repositories.in_environment(lifecycle_environment).pluck(:pulp_id)
-
-          #TODO: handle multiple variants
-          filters = [{:terms => {:repoids => repo_ids}},
-                     {:term => {:version => host.os.release}},
-                     {:term => {:arch => host.architecture.name}}]
-          distributions = Katello::Distribution.search do
-            filter :and, filters
-          end
-          distributions = distributions.select { |dist| Katello::Distribution.new(dist.as_json).bootable? }
-          distribution_repo_ids = distributions.map(&:repoids).flatten
-
-          ::Katello::Repository.where(:pulp_id => (repo_ids & distribution_repo_ids))
+          Katello::Repository.where(:distribution_version => host.os.release,
+                                    :distribution_arch => host.architecture.name,
+                                    :distribution_bootable => true
+                                    )
         else
           []
         end

app/models/katello/content_view.rb

@@ -506,52 +506,36 @@ def check_ready_to_destroy!
 
     def check_distribution_conflicts!
       duplicates = duplicate_distributions
-      pulp_repo_ids = []
       if duplicates.any?
         failed_distribution = duplicates.first
-        pulp_repo_ids = failed_distribution.repoids
       else
         conflicts = distribution_conflicts
-        if conflicts.first && conflicts.first[:distributions]
-          pulp_repo_ids = conflicts.first[:distributions].flat_map(&:repoids) & self.repositories_to_publish.map(&:pulp_id)
-          failed_distribution = conflicts.first[:distributions].first
+        if conflicts.any?
+          failed_distribution = conflicts.first
         end
       end
 
       if failed_distribution
+        failed_repos = [duplicates, conflicts].flat_map { |i| i }
         fail _("Content Views cannot contain multiple Kickstart trees with the same version and architecture. " \
                "Multiple Kickstart trees of %{release} %{arch} were found in Repositories: %{repos}") %
-                 {:release => failed_distribution.version, :arch => failed_distribution.arch,
-                  :repos => Repository.where(:pulp_id => pulp_repo_ids).pluck(:name).join(', ')}
+                 {:release => failed_distribution.distribution_version, :arch => failed_distribution.distribution_arch,
+                  :repos => failed_repos.compact.map { |repo| repo.name if repo.name }}
       end
     end
 
     def distribution_conflicts
       #find distributions, where there are two in the content view with the same version and Arch
-      repo_ids =  self.repositories_to_publish.pluck(:pulp_id)
-      distributions = Distribution.search do
-        filter :terms, :repoids => repo_ids
-      end
-      distributions = distributions.select { |dist| Katello::Distribution.new(dist.as_json).bootable? }
-
-      release_arches = {}
-      distributions.each do |dist|
-        key = [dist.version, dist.arch]
-        release_arches[key] ||= []
-        release_arches[key] << dist
-      end
-      conflicts = release_arches.map { |key, value| {:version => key[0], :arch => key[1], :distributions => value} }
-      conflicts.select { |conflict| conflict[:distributions].length > 1 }
+      repos =  self.repositories_to_publish.where("distribution_arch IS NOT NULL OR distribution_version IS NOT NULL")
+      repos = repos.select { |repo| repo.distribution_bootable? }
+      repos.group_by { |repo| [repo.distribution_arch, repo.distribution_version] }
+           .select { |_, value| value.length > 1 }.values.flatten
     end
 
     def duplicate_distributions
       #find distributions where two repositories in the content view share them
-      repo_ids =  self.repositories_to_publish.pluck(:pulp_id)
-      distributions = Distribution.search do
-        filter :terms, :repoids => repo_ids
-      end
-      distributions = distributions.select { |dist| Katello::Distribution.new(dist.as_json).bootable? }
-      distributions.find_all { |dist| (dist.repoids & repo_ids).length > 1 }
+      repos =  self.repositories_to_publish.where("distribution_uuid IS NOT NULL")
+      repos.group_by { |i| i.distribution_uuid }.select { |_, v| v.length > 1 }.values.flatten
     end
 
     protected

app/models/katello/glue/elastic_search/repository.rb

@@ -20,12 +20,6 @@ def index_puppet_modules
       end
     end
 
-    def index_distributions
-      #reindex all distributions, much simpler
-      Tire.index(Katello::Distribution.index).delete
-      Katello::Distribution.index_all
-    end
-
     def indexed_puppet_module_ids
       Katello::PuppetModule.indexed_ids_for_repo(pulp_id)
     end
@@ -40,8 +34,8 @@ def index_content
       self.index_db_errata
       self.index_db_docker_images
       self.index_puppet_modules
-      self.index_distributions
       self.index_db_package_groups
+      self.import_distribution_data
       true
     end
   end