katello 3.12.3 → 3.13.0.rc1

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

@@ -8,11 +8,25 @@ module Katello
           if: ->(setting) { setting.name == 'default_download_policy' }
 
         after_save :recalculate_errata_status
+        after_commit :update_global_proxies
       end
 
       def recalculate_errata_status
         ForemanTasks.async_task(Actions::Katello::Host::RecalculateErrataStatus) if saved_change_to_attribute?(:value) && name == 'errata_status_installable'
       end
+
+      def update_global_proxies
+        if saved_change_to_attribute?(:value) && name == 'content_default_http_proxy'
+          repos = RootRepository.with_global_proxy.collect(&:library_instance).uniq
+
+          unless repos.empty?
+            ForemanTasks.async_task(
+              ::Actions::BulkAction,
+              ::Actions::Katello::Repository::UpdateHttpProxyDetails,
+              repos.sort_by(&:pulp_id))
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,6 +1,7 @@
 require 'proxy_api'
 require 'proxy_api/pulp'
 require 'proxy_api/pulp_node'
+
 module Katello
   module Concerns
     module SmartProxyExtensions
@@ -14,6 +15,7 @@ module Katello
         end
       end
 
+      PULP3_FEATURE = "Pulp3".freeze
       PULP_FEATURE = "Pulp".freeze
       PULP_NODE_FEATURE = "Pulp Node".freeze
 
@@ -113,16 +115,15 @@ module Katello
         @pulp_api ||= Katello::Pulp::Server.config(pulp_url, User.remote_user)
       end
 
-      def pulp3_api
-        config = Zest::Configuration.new
-        config.host = pulp3_host!
-        config.username = 'admin'
-        config.password = 'password'
-        config.debugging = true
-        config.logger = ::Foreman::Logging.logger('katello/pulp_rest')
-        client = Zest::PulpApi.new
-        client.api_client.config = config
-        client
+      def pulp3_configuration(config_class)
+        config_class.new do |config|
+          config.host = pulp3_host!
+          config.scheme = 'https'
+          config.username = 'admin'
+          config.password = 'password'
+          config.debugging = true
+          config.logger = ::Foreman::Logging.logger('katello/pulp_rest')
+        end
       end
 
       def backend_service_type(repository)
@@ -133,17 +134,32 @@ module Katello
         end
       end
 
+      def pulp3_enabled?
+        self.has_feature? PULP3_FEATURE
+      end
+
       def pulp3_support?(repository)
         type = Katello::RepositoryTypeManager.repository_types[repository.content_type]
         type.pulp3_plugin && self.capabilities('Pulp3').try(:include?, type.pulp3_plugin)
       end
 
+      def content_pulp3_support?(content_type)
+        content_type = content_type.is_a?(String) ? content_type : content_type.model_class::CONTENT_TYPE
+        type = Katello::RepositoryTypeManager.find_repository_type content_type
+        type.pulp3_plugin && SmartProxy.pulp_master!.capabilities('Pulp3').try(:include?, type.pulp3_plugin)
+      end
+
       def pulp3_host!
         url = self.setting('Pulp3', 'pulp_url')
         fail "Cannot determine pulp3 url, check smart proxy configuration" unless url
         URI.parse(url).host
       end
 
+      def pulp3_url(path = nil)
+        pulp_url = self.setting('Pulp3', 'pulp_url')
+        path.blank? ? pulp_url : "#{pulp_url.sub(%r|/$|, '')}/#{path.sub(%r|^/|, '')}"
+      end
+
       def pulp_mirror?
         self.has_feature? PULP_NODE_FEATURE
       end
@@ -177,7 +193,7 @@ module Katello
         end
 
         #this will rely on smart proxy capabilities when available
-        content_type.pulp2_service_class
+        content_pulp3_support?(content_type) ? content_type.pulp3_service_class : content_type.pulp2_service_class
       end
 
       def set_default_download_policy

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

@@ -34,6 +34,7 @@ module Katello
 
         has_many :activation_keys, :through => :subscription_facet
         has_many :pools, :through => :subscription_facet
+        has_many :purpose_addons, :through => :subscription_facet
         has_many :subscriptions, :through => :pools
         has_one :subscription_status_object, :class_name => 'Katello::SubscriptionStatus', :foreign_key => 'host_id', :dependent => :destroy
         has_one :purpose_sla_status_object, :class_name => 'Katello::PurposeSlaStatus', :foreign_key => 'host_id', :dependent => :destroy
@@ -68,7 +69,7 @@ module Katello
         scoped_search :on => :id, :relation => :pools, :rename => :subscription_id, :complete_value => true, :ext_method => :find_by_subscription_id, :only_explicit => true
         scoped_search :on => :purpose_role, :rename => :role, :relation => :subscription_facet, :complete_value => true
         scoped_search :on => :purpose_usage, :rename => :usage, :relation => :subscription_facet, :complete_value => true
-        scoped_search :on => :purpose_addons, :rename => :addon, :relation => :subscription_facet, :complete_value => true
+        scoped_search :on => :name, :rename => :addon, :relation => :purpose_addons, :complete_value => true, :ext_method => :find_by_purpose_addon
       end
 
       module ClassMethods
@@ -76,6 +77,12 @@ module Katello
           ::Katello::PurposeStatus.status_map
         end
 
+        def find_by_purpose_addon(_key, operator, value)
+          conditions = sanitize_sql_for_conditions(["#{Katello::PurposeAddon.table_name}.name #{operator} ?", value_to_sql(operator, value)])
+          hosts = ::Host::Managed.joins(:purpose_addons).where(conditions)
+          return_hosts(hosts)
+        end
+
         def find_by_activation_key(_key, operator, value)
           conditions = sanitize_sql_for_conditions(["#{Katello::ActivationKey.table_name}.name #{operator} ?", value_to_sql(operator, value)])
           hosts = ::Host::Managed.joins(:activation_keys).where(conditions)

data/app/models/katello/content_view.rb

@@ -318,6 +318,10 @@ module Katello
       components.select { |component| component.repositories.where(:library_instance => library_instance).any? }
     end
 
+    def auto_publish_components
+      component_composites.where(latest: true).joins(:composite_content_view).where(self.class.table_name => {auto_publish: true})
+    end
+
     def publish_repositories
       repositories = composite? ? repositories_to_publish_by_library_instance.values : repositories_to_publish
       repositories.each do |repos|

data/app/models/katello/content_view_filter.rb

@@ -13,12 +13,8 @@ module Katello
                :class_name => "Katello::ContentView",
                :inverse_of => :filters
 
-    # rubocop:disable HasAndBelongsToMany
-    # TODO: change these into has_many :through associations
-    has_and_belongs_to_many :repositories,
-                            :uniq => true,
-                            :class_name => "Katello::Repository",
-                            :join_table => :katello_content_view_filters_repositories
+    has_many :repository_content_view_filters, :class_name => "Katello::RepositoryContentViewFilter", :dependent => :delete_all, :inverse_of => :filter, :foreign_key => :content_view_filter_id
+    has_many :repositories, :through => :repository_content_view_filters, :class_name => "Katello::Repository"
 
     validates_lengths_from_database
     validate :validate_content_view
@@ -124,8 +120,8 @@ module Katello
     end
 
     def self.applicable(repo)
-      query = %{ (katello_content_view_filters.id in (select content_view_filter_id from katello_content_view_filters_repositories where repository_id = #{repo.id})) or
-                 (katello_content_view_filters.id not in (select content_view_filter_id from katello_content_view_filters_repositories))
+      query = %{ (katello_content_view_filters.id in (select content_view_filter_id from katello_repository_content_view_filters where repository_id = #{repo.id})) or
+                 (katello_content_view_filters.id not in (select content_view_filter_id from katello_repository_content_view_filters))
                }
       where(query).select("DISTINCT katello_content_view_filters.id")
     end

data/app/models/katello/docker_tag.rb

@@ -48,10 +48,16 @@ module Katello
       where(:id => ids)
     end
 
-    def self.import_all(pulp_ids = nil, options = {})
-      ::Katello::DockerTag.destroy_all if pulp_ids.blank?
-      super
-      ::Katello::DockerTag.where(:repository_id => nil).destroy_all
+    def self.import_for_repository(repository)
+      self.where(:repository_id => repository).destroy_all
+      super(repository)
+      pulp_ids = self.where(:repository_id => repository.id).pluck(:pulp_id)
+      import_all(pulp_ids) unless pulp_ids.blank?
+    end
+
+    def self.import_all(pulp_ids = nil)
+      self.destroy_all if pulp_ids.blank?
+      self.where(:repository_id => nil).destroy_all
       if pulp_ids
         repos = ::Katello::Repository.joins(:docker_tags).where("katello_docker_tags.pulp_id" => pulp_ids).distinct
         ::Katello::DockerMetaTag.import_meta_tags(repos)
@@ -60,12 +66,7 @@ module Katello
       end
     end
 
-    def self.import_for_repository(repository, _force)
-      ::Katello::DockerTag.where(:repository_id => repository).destroy_all
-      super(repository, true)
-    end
-
-    def self.manage_repository_association
+    def self.many_repository_associations
       false
     end
 

data/app/models/katello/erratum.rb

@@ -34,6 +34,14 @@ module Katello
     scoped_search :relation => :packages, :on => :nvrea, :rename => :package, :complete_value => true, :only_explicit => true
     scoped_search :relation => :packages, :on => :name, :rename => :package_name, :complete_value => true, :only_explicit => true
 
+    scoped_search :on => :modular,
+                  :only_explicit => true,
+                  :ext_method => :find_by_modular,
+                  :complete_value => {:true => 0, :false => 1},
+                  :special_values => ['true', 'false'],
+                  :validator => ->(value) { ['true', 'false'].include?(value.downcase) },
+                  :operators => ["="]
+
     before_save lambda { |erratum| erratum.title = erratum.title.truncate(255) unless erratum.title.blank? }
 
     def self.of_type(type)
@@ -43,6 +51,8 @@ module Katello
     scope :security, -> { of_type(Erratum::SECURITY) }
     scope :bugfix, -> { of_type(Erratum::BUGZILLA) }
     scope :enhancement, -> { of_type(Erratum::ENHANCEMENT) }
+    scope :modular, -> { where(:id => Erratum.joins(:packages => :module_stream_errata_packages)) }
+    scope :non_modular, -> { where.not(:id => modular) }
 
     def self.repository_association_class
       RepositoryErratum
@@ -132,6 +142,18 @@ module Katello
       return streams.flatten.uniq
     end
 
+    def self.find_by_modular(_key, operator, value)
+      conditions = ""
+      if operator == '='
+        query = value.downcase == "true" ? modular : non_modular
+        conditions = "#{table_name}.id in (#{query.select(:id).to_sql})"
+      else
+        #failure condition. No such value so must return 0
+        conditions = "1=0"
+      end
+      { :conditions => conditions }
+    end
+
     class Jail < ::Safemode::Jail
       allow :errata_id, :errata_type, :issued, :created_at, :severity, :package_names, :cves, :reboot_suggested
     end

data/app/models/katello/event.rb

@@ -4,6 +4,8 @@ module Katello
     # Note: Do not use active record call backs or dependent references on this class
     # Direct deletes are made in EventQueue#clear_events (instead of destroys).
 
+    serialize :metadata, Hash
+
     def validate_event_type
       unless EventQueue.supported_event_types.include?(self.event_type)
         errors.add(:event_type, _("Unsupported event type %{type}. Supported: %{types}") %

data/app/models/katello/events/auto_publish_composite_view.rb

@@ -0,0 +1,41 @@
+module Katello
+  module Events
+    class AutoPublishCompositeView
+      EVENT_TYPE = 'auto_publish_composite_view'.freeze
+
+      attr_reader :composite_view
+      attr_accessor :metadata, :retry
+
+      def self.retry_seconds
+        180
+      end
+
+      def initialize(composite_view_id)
+        @composite_view = ::Katello::ContentView.find_by_id(composite_view_id)
+        Rails.logger.warn "Content View not found for ID #{object_id}" if @composite_view.nil?
+        yield(self) if block_given?
+      end
+
+      def run
+        return unless composite_view
+
+        begin
+          ForemanTasks.async_task(::Actions::Katello::ContentView::Publish,
+                              composite_view,
+                              metadata[:description],
+                              triggered_by: metadata[:version_id])
+        rescue => e
+          self.retry = true if e.is_a?(ForemanTasks::Lock::LockConflict)
+          deliver_failure_notification
+          raise e
+        end
+      end
+
+      private
+
+      def deliver_failure_notification
+        ::Katello::UINotifications::ContentView::AutoPublishFailure.deliver!(composite_view)
+      end
+    end
+  end
+end

data/app/models/katello/glue/pulp/repo.rb

@@ -137,21 +137,6 @@ module Katello
         content_unit_counts
       end
 
-      def sync(options = {})
-        sync_options = {}
-        sync_options[:max_speed] ||= SETTINGS[:katello][:pulp][:sync_KBlimit] if SETTINGS[:katello][:pulp][:sync_KBlimit] # set bandwidth limit
-        sync_options[:num_threads] ||= SETTINGS[:katello][:pulp][:sync_threads] if SETTINGS[:katello][:pulp][:sync_threads] # set threads per sync
-        pulp_tasks = Katello.pulp_server.extensions.repository.sync(self.pulp_id, :override_config => sync_options)
-
-        task = PulpSyncStatus.using_pulp_task(pulp_tasks) do |t|
-          t.organization = organization
-          t.parameters ||= {}
-          t.parameters[:options] = options
-        end
-        task.save!
-        return [task]
-      end
-
       def clone_file_metadata(to_repo)
         Katello.pulp_server.extensions.yum_repo_metadata_file.copy(self.pulp_id, to_repo.pulp_id)
       end

data/app/models/katello/host/content_facet.rb

@@ -28,12 +28,43 @@ module Katello
       validates :host, :presence => true, :allow_blank => false
       validates_with Validators::ContentViewEnvironmentValidator
 
+      def bindable_types
+        [
+          {
+            type: Repository::DEB_TYPE,
+            matcher: '/pulp/deb/',
+            paths: []
+          },
+          {
+            type: Repository::YUM_TYPE,
+            matcher: '/pulp/repos/',
+            paths: []
+          }
+        ]
+      end
+
       def update_repositories_by_paths(paths)
-        paths = paths.map { |path| path.gsub('/pulp/repos/', '') }
-        repos = Repository.where(:relative_path => paths)
+        bindable_paths = bindable_types
+        relative_paths = []
+
+        paths.each do |path|
+          bindable_paths.each do |supported|
+            relative_path = path.gsub(supported[:matcher], '')
+            relative_paths << relative_path
+            if path.starts_with?(supported[:matcher])
+              supported[:paths] << relative_path
+              break
+            end
+          end
+        end
+
+        repos = bindable_paths.flat_map do |supported|
+          repos = Repository.joins(:root).where(RootRepository.table_name => {content_type: supported[:type]}, relative_path: supported[:paths])
+          relative_paths -= repos.pluck(:relative_path)
+          repos
+        end
 
-        missing = paths - repos.pluck(:relative_path)
-        missing.each do |repo_path|
+        relative_paths.each do |repo_path|
           Rails.logger.warn("System #{self.host.name} (#{self.host.id}) requested binding to unknown repo #{repo_path}")
         end
 

data/app/models/katello/host/subscription_facet.rb

@@ -4,6 +4,7 @@ module Katello
       audited :associated_with => :host, :associations => [:pools], :except => [:last_checkin]
       self.table_name = 'katello_subscription_facets'
       include Facets::Base
+      include DirtyAssociations
 
       belongs_to :user, :inverse_of => :subscription_facets, :class_name => "::User"
       belongs_to :hypervisor_host, :class_name => "::Host::Managed", :foreign_key => "hypervisor_host_id"
@@ -11,6 +12,9 @@ module Katello
       has_many :subscription_facet_activation_keys, :class_name => "Katello::SubscriptionFacetActivationKey", :dependent => :destroy, :inverse_of => :subscription_facet
       has_many :activation_keys, :through => :subscription_facet_activation_keys, :class_name => "Katello::ActivationKey"
 
+      has_many :subscription_facet_purpose_addons, :class_name => "Katello::SubscriptionFacetPurposeAddon", :dependent => :destroy, :inverse_of => :subscription_facet
+      has_many :purpose_addons, :class_name => "Katello::PurposeAddon", :through => :subscription_facet_purpose_addons
+
       has_many :subscription_facet_pools, :class_name => "Katello::SubscriptionFacetPool", :dependent => :delete_all, :inverse_of => :subscription_facet
       has_many :pools, :through => :subscription_facet_pools, :class_name => "Katello::Pool"
 
@@ -19,13 +23,13 @@ module Katello
 
       has_many :compliance_reasons, :class_name => "Katello::ComplianceReason", :dependent => :destroy, :inverse_of => :subscription_facet
 
-      serialize :purpose_addons, Array
-
       validates :host, :presence => true, :allow_blank => false
 
       DEFAULT_TYPE = 'system'.freeze
 
-      accepts_nested_attributes_for :installed_products
+      accepts_nested_attributes_for :installed_products, :purpose_addons
+
+      dirty_has_many_associations :purpose_addons
 
       attr_accessor :facts
 
@@ -53,7 +57,9 @@ module Katello
         self.update_installed_products(consumer_params['installedProducts']) if consumer_params.key?('installedProducts')
         self.purpose_role = consumer_params['role'] unless consumer_params['role'].nil?
         self.purpose_usage = consumer_params['usage'] unless consumer_params['usage'].nil?
-        self.purpose_addons = consumer_params['addOns'] unless consumer_params['addOns'].nil?
+        unless consumer_params['addOns'].nil?
+          self.purpose_addon_ids = consumer_params['addOns'].map { |addon_name| ::Katello::PurposeAddon.find_or_create_by(name: addon_name).id }
+        end
 
         unless consumer_params['releaseVer'].blank?
           release = consumer_params['releaseVer']
@@ -127,7 +133,7 @@ module Katello
           :autoheal => autoheal,
           :usage => purpose_usage,
           :role => purpose_role,
-          :addOns => purpose_addons,
+          :addOns => purpose_addons.pluck(:name),
           :serviceLevel => service_level,
           :releaseVer => release_version,
           :environment => {:id => self.candlepin_environment_id},
@@ -266,17 +272,9 @@ module Katello
 
         if hosts_size == 1
           host = hosts.first
+          found_uuid = host.fact_values.find { |fv| fv.fact_name_id == uuid_fact_id }
 
-          if host.name == host_name
-            unless host.build
-              found_uuid = host.fact_values.where(fact_name_id: uuid_fact_id).first
-              if found_uuid && found_uuid.value != host_uuid
-                fail Katello::Errors::RegistrationError, _("This host is reporting a DMI UUID that differs from the existing registration.")
-              end
-            end
-
-            return host
-          end
+          return host if host.name == host_name && (host.build || found_uuid&.value == host_uuid)
         end
 
         hostnames = hosts.pluck(:name).sort.join(', ')
@@ -292,7 +290,7 @@ module Katello
       end
 
       def backend_update_needed?
-        %w(release_version service_level autoheal purpose_role purpose_usage purpose_addons).each do |method|
+        %w(release_version service_level autoheal purpose_role purpose_usage purpose_addon_ids).each do |method|
           return true if self.send("#{method}_changed?")
         end
         if self.host.content_facet