katello 3.9.1 → 3.10.0.rc1

data/app/lib/actions/pulp/repository/refresh.rb

@@ -4,80 +4,17 @@ module Actions
       class Refresh < Pulp::Abstract
         input_format do
           param :capsule_id
+          param :pulp_id
         end
 
-        def plan(repository, input = {})
-          input[:capsule_id] ||= SmartProxy.default_capsule!.id
-          repository_details = pulp_extensions(input[:capsule_id]).repository.retrieve_with_details(repository.pulp_id)
-          update_or_associate_importer(input[:capsule_id], repository, repository_details)
-          update_or_associate_distributors(input[:capsule_id], repository, repository_details)
-          remove_unnecessary_distributors(input[:capsule_id], repository, repository_details)
+        def plan(repository, options = {})
+          options[:capsule_id] ||= SmartProxy.default_capsule!.id
+          plan_self(:capsule_id => options[:capsule_id], :pulp_id => repository.pulp_id)
         end
 
-        def update_or_associate_importer(capsule_id, repository, repository_details)
-          existing_importers = repository_details["importers"]
-          importer = repository.generate_importer(::SmartProxy.find_by(:id => capsule_id))
-          found = existing_importers.find { |i| i['importer_type_id'] == importer.id }
-
-          if found
-            plan_action(::Actions::Pulp::Repository::UpdateImporter,
-                        :repo_id => repository.pulp_id,
-                        :id => found['id'],
-                        :config => importer.config,
-                        :capsule_id => capsule_id
-                       )
-          else
-            plan_action(::Actions::Pulp::Repository::AssociateImporter,
-                        :repo_id => repository.pulp_id,
-                        :type_id => repository.importers.first['importer_type_id'],
-                        :config => importer.config,
-                        :capsule_id => capsule_id,
-                        :hash => { :importer_id => importer.id }
-                       )
-          end
-        end
-
-        def update_or_associate_distributors(capsule_id, repository, repository_details)
-          concurrence do
-            existing_distributors = repository_details["distributors"]
-            capsule = capsule_id ? SmartProxy.find(capsule_id) : nil
-            repository.generate_distributors(capsule).each do |distributor|
-              found = existing_distributors.find { |i| i['distributor_type_id'] == distributor.type_id }
-              if found
-                plan_action(::Actions::Pulp::Repository::RefreshDistributor,
-                            :repo_id => repository.pulp_id,
-                            :id => found['id'],
-                            :config => distributor.config,
-                            :capsule_id => capsule_id
-                           )
-              else
-                plan_action(::Actions::Pulp::Repository::AssociateDistributor,
-                            :repo_id => repository.pulp_id,
-                            :type_id => distributor.type_id,
-                            :config => distributor.config,
-                            :capsule_id => capsule_id,
-                            :hash => { :distributor_id => distributor.id }
-                           )
-              end
-            end
-          end
-        end
-
-        def remove_unnecessary_distributors(capsule_id, repository, repository_details)
-          concurrence do
-            existing_distributors = repository_details["distributors"]
-            capsule = capsule_id ? SmartProxy.find(capsule_id) : nil
-            generated_distributors = repository.generate_distributors(capsule)
-            existing_distributors.each do |distributor|
-              found = generated_distributors.find { |dist| dist.type_id == distributor['distributor_type_id'] }
-              unless found
-                plan_action(Pulp::Repository::DeleteDistributor, :repo_id => repository.pulp_id,
-                                                                 :distributor_id => distributor['id'],
-                                                                 :capsule_id => capsule_id
-                           )
-              end
-            end
-          end
+        def run
+          repo = ::Katello::Repository.find_by(:pulp_id => input[:pulp_id])
+          output[:results] = repo.backend_service(smart_proxy(input[:capsule_id])).refresh
         end
       end
     end

data/app/lib/actions/pulp/repository/sync.rb

@@ -21,8 +21,7 @@ module Actions
             overrides[:validate] = !(SETTINGS[:katello][:pulp][:skip_checksum_validation])
             overrides[:options] = input[:options] if input[:options]
             repo = ::Katello::Repository.find_by(:pulp_id => input[:pulp_id])
-            output[:pulp_tasks] = pulp_tasks = ::Katello::Pulp::Repository.new(repo, smart_proxy(input[:capsule_id])).sync(overrides)
-            pulp_tasks
+            output[:pulp_tasks] = repo.backend_service(::SmartProxy.pulp_master).sync(overrides)
           end
         end
 

data/app/lib/katello/capsule_content.rb

@@ -92,7 +92,7 @@ module Katello
     end
 
     def default_capsule?
-      @capsule.default_capsule?
+      @capsule.pulp_master?
     end
 
     def orphaned_repos
@@ -132,7 +132,7 @@ module Katello
     end
 
     def pulp_url
-      "https://" + self.capsule.hostname + "/pulp/api/v2/"
+      self.capsule.pulp_url
     end
 
     def pulp_repo_facts(pulp_id)
@@ -164,7 +164,7 @@ module Katello
     end
 
     def self.default_capsule
-      proxy = SmartProxy.with_features(SmartProxy::PULP_FEATURE).first
+      proxy = SmartProxy.pulp_master
       self.new(proxy) if proxy
     end
 

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

@@ -22,7 +22,7 @@ module Katello
               includes = params.key?(:include_only) ? "&" + included_list(params.delete(:include_only)) : ""
               fetch_paged do |page_add|
                 response = super(path + hash_to_query(params) + includes + "&#{page_add}", self.default_headers).body
-                JSON.parse(response)
+                JSON.parse(response).map(&:with_indifferent_access)
               end
             end
           end

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

@@ -9,7 +9,7 @@ module Katello
           end
 
           def find_for_stacking_id(owner_key, stacking_id)
-            Subscription.get_for_owner(owner_key).each do |subscription|
+            Resources::Candlepin::Subscription.get_for_owner(owner_key).each do |subscription|
               if subscription['product']['attributes'].any? { |attr| attr['name'] == 'stacking_id' && attr['value'] == stacking_id }
                 return subscription['product']
               end

data/app/lib/katello/validators/hostgroup_kickstart_repository_validator.rb

@@ -18,7 +18,7 @@ module Katello
                 _("Kickstart repositories can only be assigned to hosts in the Red Hat family")
               elsif hostgroup.architecture.blank?
                 _("Please select an architecture before assigning a kickstart repository")
-              elsif hostgroup.operatingsystem.kickstart_repos(hostgroup).none? { |repo| repo[:id] == hostgroup.kickstart_repository_id }
+              elsif !hostgroup.matching_kickstart_repository?
                 _("The selected kickstart repository is not part of the assigned content view, lifecycle environment,
                   content source, operating system, and architecture")
               end

data/app/models/katello/available_module_stream.rb

@@ -0,0 +1,11 @@
+module Katello
+  class AvailableModuleStream < Katello::Model
+    has_many :hosts, :through => :host_available_module_streams, :class_name => "::Host"
+    has_many :host_available_module_streams, :class_name => "Katello::HostAvailableModuleStream", :dependent => :destroy, :inverse_of => :available_module_stream
+    serialize :profiles
+
+    def module_spec
+      "#{name}:#{stream}"
+    end
+  end
+end

data/app/models/katello/concerns/content_facet_host_extensions.rb

@@ -30,6 +30,7 @@ module Katello
         has_one :content_source, :through => :content_facet
         has_many :applicable_errata, :through => :content_facet
         has_many :applicable_rpms, :through => :content_facet
+        has_many :applicable_module_streams, :through => :content_facet
 
         scoped_search :relation => :content_view, :on => :name, :complete_value => true, :rename => :content_view
         scoped_search :relation => :content_facet, :on => :content_view_id, :rename => :content_view_id, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER

data/app/models/katello/concerns/host_managed_extensions.rb

@@ -35,6 +35,10 @@ module Katello
 
         has_many :host_installed_packages, :class_name => "::Katello::HostInstalledPackage", :foreign_key => :host_id, :dependent => :delete_all
         has_many :installed_packages, :class_name => "::Katello::InstalledPackage", :through => :host_installed_packages
+
+        has_many :host_available_module_streams, :class_name => "::Katello::HostAvailableModuleStream", :foreign_key => :host_id, :dependent => :delete_all
+        has_many :available_module_streams, :class_name => "::Katello::AvailableModuleStream", :through => :host_available_module_streams
+
         has_many :host_traces, :class_name => "::Katello::HostTracer", :foreign_key => :host_id, :dependent => :destroy
 
         has_many :host_collection_hosts, :class_name => "::Katello::HostCollectionHosts", :foreign_key => :host_id, :dependent => :destroy
@@ -49,6 +53,8 @@ module Katello
         scoped_search :relation => :host_collections, :on => :name, :complete_value => true, :rename => :host_collection
         scoped_search :relation => :installed_packages, :on => :nvra, :complete_value => true, :rename => :installed_package, :only_explicit => true
         scoped_search :relation => :installed_packages, :on => :name, :complete_value => true, :rename => :installed_package_name, :only_explicit => true
+        scoped_search :relation => :available_module_streams, :on => :name, :complete_value => true, :rename => :available_module_stream_name, :only_explicit => true
+        scoped_search :relation => :available_module_streams, :on => :stream, :complete_value => true, :rename => :available_module_stream_stream, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :application, :complete_value => true, :rename => :trace_app, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :app_type, :complete_value => true, :rename => :trace_app_type, :only_explicit => true
         scoped_search :relation => :host_traces, :on => :helper, :complete_value => true, :rename => :trace_helper, :only_explicit => true
@@ -110,6 +116,56 @@ module Katello
         found
       end
 
+      def import_enabled_repositories(repos)
+        paths = repos.map do |repo|
+          if !repo['baseurl'].blank?
+            URI(repo['baseurl'].first).path
+          else
+            logger.warn("System #{name} (#{id}) attempted to bind to unspecific repo (#{repo}).")
+            nil
+          end
+        end
+        content_facet.update_repositories_by_paths(paths.compact)
+      end
+
+      def import_module_streams(module_streams)
+        streams = {}
+        module_streams.each do |module_stream|
+          stream = AvailableModuleStream.where(name: module_stream["name"],
+                                               stream: module_stream["stream"]).first_or_create!
+          streams[stream.id] = module_stream
+        end
+        sync_available_module_stream_associations(streams)
+      end
+
+      def sync_available_module_stream_associations(new_available_module_streams)
+        upgradable_streams = self.host_available_module_streams.where(:available_module_stream_id => new_available_module_streams.keys)
+        old_associated_ids = self.available_module_stream_ids
+        delete_ids = old_associated_ids - new_available_module_streams.keys
+
+        if delete_ids.any?
+          self.host_available_module_streams.where(:available_module_stream_id => delete_ids).delete_all
+        end
+
+        new_ids = new_available_module_streams.keys - old_associated_ids
+        new_ids.each do |new_id|
+          module_stream = new_available_module_streams[new_id]
+          self.host_available_module_streams.create!(host_id: self.id,
+                                                     available_module_stream_id: new_id,
+                                                     installed_profiles: module_stream["installed_profiles"],
+                                                     status: module_stream["status"])
+        end
+
+        upgradable_streams.each do |hams|
+          module_stream = new_available_module_streams[hams.available_module_stream_id]
+          shared_keys = hams.attributes.keys & module_stream.keys
+          module_stream_data = module_stream.slice(*shared_keys)
+          if hams.attributes.slice(*shared_keys) != module_stream_data
+            hams.update_attributes!(module_stream_data)
+          end
+        end
+      end
+
       def sync_package_associations(new_installed_package_ids)
         old_associated_ids = self.installed_package_ids
         table_name = self.host_installed_packages.table_name

data/app/models/katello/concerns/hostgroup_extensions.rb

@@ -30,6 +30,12 @@ module Katello
         elsif kickstart_repository && medium
           self.medium = nil
         end
+
+        unless matching_kickstart_repository?
+          if (equivalent = equivalent_kickstart_repository)
+            self.kickstart_repository_id = equivalent[:id]
+          end
+        end
       end
 
       def content_view
@@ -81,6 +87,17 @@ module Katello
             self.lifecycle_environment == self.environment.try(:lifecycle_environment)
       end
 
+      def equivalent_kickstart_repository
+        return unless operatingsystem && kickstart_repository
+        ks_repos = operatingsystem.kickstart_repos(self)
+        ks_repos.find { |repo| repo[:name] == kickstart_repository.label }
+      end
+
+      def matching_kickstart_repository?
+        return true unless operatingsystem
+        operatingsystem.kickstart_repos(self).any? { |repo| repo[:id] == kickstart_repository_id }
+      end
+
       private
 
       def inherited_ancestry_attribute(attribute)

data/app/models/katello/concerns/redhat_extensions.rb

@@ -41,16 +41,31 @@ module Katello
       end
 
       def kickstart_repos(host)
-        distros = distribution_repositories(host)
+        distribution_repos = distribution_repositories(host)
+
+        return [] if distribution_repos.empty?
+
+        distros = distribution_repos.where(distribution_bootable: true)
         if distros && host.content_source
-          distros.map do |distro|
-            {:id => distro.id, :name => distro.name, :path => distro.full_path(host.content_source)}
-          end
+          distros.map { |distro| distro.to_hash(host.content_source) }
         else
           []
         end
       end
 
+      def variant_repo(host, variant)
+        if variant && host.content_source
+          product_id = host&.content_facet&.kickstart_repository&.product_id
+          distro = distribution_repositories(host)
+            .joins(:product)
+            .where(
+              distribution_variant: variant,
+              "#{Katello::Product.table_name}.id": product_id
+            ).first
+          distro.to_hash(host.content_source) if distro
+        end
+      end
+
       def distribution_repositories(host)
         content_view = host.try(:content_facet).try(:content_view) || host.try(:content_view)
         lifecycle_environment = host.try(:content_facet).try(:lifecycle_environment) || host.try(:lifecycle_environment)
@@ -58,8 +73,7 @@ module Katello
         if content_view && lifecycle_environment && host.os && host.architecture
           Katello::Repository.in_environment(lifecycle_environment).in_content_views([content_view]).
               where(:distribution_version => host.os.release,
-                    :distribution_arch => host.architecture.name,
-                    :distribution_bootable => true)
+                    :distribution_arch => host.architecture.name)
         else
           []
         end

data/app/models/katello/concerns/search_by_repository_name.rb

@@ -1,4 +1,3 @@
-
 module Katello
   module Concerns
     module SearchByRepositoryName

data/app/models/katello/concerns/smart_proxy_extensions.rb

@@ -62,14 +62,20 @@ module Katello
         }
         scope :with_content, -> { with_features(PULP_FEATURE, PULP_NODE_FEATURE) }
 
-        def self.default_capsule
+        def self.pulp_master
           unscoped.with_features(PULP_FEATURE).first
         end
 
+        def self.pulp_master!
+          pulp_master || fail(_("Could not find a smart proxy with pulp feature."))
+        end
+
+        def self.default_capsule
+          pulp_master
+        end
+
         def self.default_capsule!
-          capsule = default_capsule
-          fail _("Could not find a smart proxy with pulp feature.") if capsule.nil?
-          capsule
+          pulp_master!
         end
       end
 
@@ -87,26 +93,34 @@ module Katello
         path
       end
 
-      def pulp_node
-        @pulp_node ||= Katello::Pulp::Server.config(pulp_url, User.remote_user)
-      end
-
       def pulp_url
         uri = URI.parse(url)
         "#{uri.scheme}://#{uri.host}/pulp/api/v2/"
       end
 
-      def default_capsule?
+      def pulp_api
+        @pulp_api ||= Katello::Pulp::Server.config(pulp_url, User.remote_user)
+      end
+
+      def pulp_mirror?
+        self.features.map(&:name).include?(PULP_NODE_FEATURE)
+      end
+
+      def pulp_master?
         # use map instead of pluck in case the features aren't saved yet during create
         self.features.map(&:name).include?(PULP_FEATURE)
       end
 
+      #deprecated methods
+      alias_method :pulp_node, :pulp_api
+      alias_method :default_capsule?, :pulp_master?
+
       def associate_organizations
-        self.organizations = Organization.all if self.default_capsule?
+        self.organizations = Organization.all if self.pulp_master?
       end
 
       def associate_default_locations
-        return unless default_capsule?
+        return unless pulp_master?
         ['puppet_content', 'subscribed_hosts'].each do |type|
           default_location = ::Location.unscoped.find_by_title(
             ::Setting[:"default_location_#{type}"])
@@ -121,7 +135,7 @@ module Katello
       end
 
       def associate_lifecycle_environments
-        self.lifecycle_environments = Katello::KTEnvironment.all if self.default_capsule?
+        self.lifecycle_environments = Katello::KTEnvironment.all if self.pulp_master?
       end
     end
   end

data/app/models/katello/content_facet_applicable_module_stream.rb

@@ -0,0 +1,7 @@
+module Katello
+  class ContentFacetApplicableModuleStream < Katello::Model
+    # Do not use active record callbacks in this join model.  Direct INSERTs and DELETEs are done
+    belongs_to :content_facet, :inverse_of => :content_facet_applicable_rpms, :class_name => 'Katello::Host::ContentFacet'
+    belongs_to :module_stream, :inverse_of => :content_facet_applicable_module_streams, :class_name => 'Katello::ModuleStream'
+  end
+end

data/app/models/katello/content_view_puppet_environment.rb

@@ -34,10 +34,6 @@ module Katello
       Repository::PUPPET_TYPE
     end
 
-    def unprotected
-      false
-    end
-
     def mirror_on_sync?
       true
     end
@@ -50,20 +46,12 @@ module Katello
       true
     end
 
-    def node_syncable?
-      environment
-    end
-
-    def ssl_client_cert
-      false
-    end
-
-    def ssl_client_key
-      false
+    def backend_service(smart_proxy)
+      @service ||= Katello::Pulp::Repository.instance_for_type(nonpersisted_repository, smart_proxy)
     end
 
-    def ssl_ca_cert
-      false
+    def node_syncable?
+      environment
     end
 
     def organization
@@ -91,25 +79,16 @@ module Katello
       self.environment.nil?
     end
 
-    def generate_puppet_path(capsule)
-      # rubocop:disable Style/EmptyElse
-      if self.environment
-        File.join(capsule.puppet_path, generate_puppet_env_name, 'modules')
-      else
-        nil #don't generate archived content view puppet environments
-      end
-    end
-
-    def generate_puppet_env_name
-      if self.environment
-        Environment.construct_name(self.organization,
-                                   self.environment,
-                                   self.content_view)
-      end
-    end
-
-    def ignore_global_proxy
-      false
+    def nonpersisted_repository
+      #This creates a mock repository that can be used
+      root = ::Katello::RootRepository.new(content_type: ::Katello::Repository::PUPPET_TYPE,
+                                           name: "#{content_view.name} Puppet Environment",
+                                           mirror_on_sync: true,
+             product: Product.new(:organization => organization))
+      ::Katello::Repository.new(root: root,
+                                pulp_id: pulp_id,
+                                content_view_version: content_view_version,
+                                environment: environment)
     end
 
     def set_pulp_id